How to use the yup.ref function in yup

(password, field) =>
          password ? field.required().oneOf([Yup.ref('password')]) : field // ref=> referencua
      ),

import styles from './RegistrationForm.css';

const registrationSchema = Yup.object().shape({
  email: Yup.string()
    .required(validationErrorMessages.required)
    .email(validationErrorMessages.email),
  'confirm-email': Yup.string()
    .required(validationErrorMessages.required)
    .oneOf([Yup.ref('email')], validationErrorMessages.emailMatch),
  password: Yup.string()
    .required(validationErrorMessages.required)
    .min(minimumPasswordLength, validationErrorMessages.length(minimumPasswordLength))
    .test('password-strength', validationErrorMessages.password, isMinPasswordStrength),
  'confirm-password': Yup.string()
    .required(validationErrorMessages.required)
    .oneOf([Yup.ref('password')], validationErrorMessages.passwordMatch),
  firstName: Yup.string().required(validationErrorMessages.required),
  lastName: Yup.string().required(validationErrorMessages.required),
  zipcode: Yup.string()
    .required(validationErrorMessages.required)
    .test('zipcode', validationErrorMessages.zipcode, isValidZipcode),
});

RegistrationForm.propTypes = {
  onSuccess: func.isRequired,
  initialValues: shape({
    email: string,
    'confirm-email': string,
    password: string,
    'confirm-password': string,
    firstName: string,
    lastName: string,

.max(255)
    .required(passwordRequired)
});

export const RegisterValidation = Yup.object().shape({
  email: Yup.string()
    .min(3, emailLength)
    .max(255)
    .email(invalidEmail)
    .required(emailRequired),
  password: Yup.string()
    .min(3, passwordLength)
    .max(255)
    .required(passwordRequired),
  confirmPassword: Yup.string()
    .oneOf([Yup.ref("password"), null], "Password Fields must match")
    .required("Confirm Password is required"),
  username: Yup.string()
    .min(3, "Username must be at least 3 characters")
    .required("Required")
});

export const ChangePasswordTradingAccountValidationSchema = (
  params: i18next.WithT & IChangePasswordTradingAccountValidationSchema
) =>
  object().shape({
    twoFactorCode: twoFactorValidator(params),
    password: passwordValidator({ t: params.t }),
    confirmPassword: string()
      .oneOf(
        [ref("password")],
        params.t(
          "password-change-trading-account.validators.password-dont-match"
        )
      )
      .required(
        params.t(
          "password-change-trading-account.validators.confirm-password-required"
        )
      )
  });

import React, { useState } from 'react';
import { withRouter } from "react-router-dom";
import * as accountService from "../services/account-service";
import { Formik, Form, Field, ErrorMessage } from "formik";
import * as Yup from "yup";
import clsx from 'clsx';
import { useStyles } from './ResetPasswordRequest'


const validationSchema = Yup.object().shape({
  password: Yup.string()
  .min(8, "Password must be atleast 8 characters")
  .required('Password is Required'),
  passwordConfirm: Yup.string()
    .required("Confirm your password")
    .oneOf([Yup.ref("password")], "Password does not match")
})

export function ResetPassword(props) {
  const [ success, setSuccess ] = useState(false);
  const { token } = props.match.params;
  const classes = useStyles();

  const handleSubmit = async (
    { token, password}, { setFieldError }
  ) => {
    const submitResponse = await accountService
      .resetPassword({ token, password });
      if (submitResponse.data.isSuccess) {
        setSuccess(true)
      } else  {
        setFieldError('passwordConfirm', submitResponse.data.message)

validationSchema: ({ t }) =>
      object().shape({
        password: string()
          .min(6, t("auth.password-restore.validators.password-weak"))
          .required(t("auth.password-restore.validators.password-required")),
        confirmPassword: string()
          .oneOf(
            [ref("password")],
            t("auth.password-restore.validators.password-dont-match")
          )
          .required(
            t("auth.password-restore.validators.confirm-password-required")
          )
      }),
    handleSubmit: (values, { props, setSubmitting }) => {

const passwordValidation = t => Yup.object().shape({
  password: Yup.string().required(t('This field is required')),
  confirmation: Yup.string()
    .oneOf([Yup.ref('password'), null], t('The values do not match'))
    .required(t('This field is required')),
});

} else {
                    schema = schema.mixed();
                  }

                  if (shouldBeRequired(inputField.name, fieldConfig)) {
                    schema = schema.required('Required');
                  } else {
                    schema = schema.nullable();
                  }

                  if (
                    ['Password'].includes(typeName) ||
                    fieldConfig.widget === 'Password'
                  ) {
                    const confirmSchema = schema.oneOf(
                      [yup.ref(inputField.name)],
                      'Passwords must match'
                    );
                    acc[`${inputField.name}Confirm`] = confirmSchema;

                    schema = schema.oneOf(
                      [yup.ref(`${inputField.name}Confirm`)],
                      'Passwords must match'
                    );
                  }

                  acc[inputField.name] = schema;

                  return acc;
                },
                {}

val =
                    val[currentLocale] || val[deviceLanguage] || val.default;
                }
                params.push(val);
              });
            }
            validator[f.name] = validator[f.name][v.name].apply(
              validator[f.name],
              params,
            );
          });
          if (
            ['password-confirmation', 'passwordConfirmation'].includes(f.name)
          ) {
            validator[f.name] = validator[f.name].oneOf(
              [yup.ref('password'), null],
              f.passwordConfirmationMessage[currentLocale] ||
                f.passwordConfirmationMessage[deviceLanguage] ||
                f.passwordConfirmationMessage.default,
            );
          }
        }
      });
    });

import React, { Fragment } from 'react'
import { FastField, Form, Formik } from 'formik'
import { PanelCard, PanelCardHeader } from '@components/PanelShell'
import { LockOpenIcon } from 'mdi-react'
import Yup from 'yup'
import { Button } from '@components/styled/Button'
import PropTypes from 'prop-types'

const validationSchema = Yup.object({
  password: Yup.string()
    .min(8, 'Your password is too short.')
    .required('A passsword is required.'),
  passwordConfirm: Yup.string()
    .oneOf([Yup.ref('password')], 'Passwords do not match.')
    .required('Please confirm your password.')
})

const panelHeader = () => (
  
)

const Password = ({ next, updateValue, password, ...rest }) => (