@dynamic-labs/sdk-react-core 2.1.0-alpha.9 → 2.1.1

package/src/lib/utils/hooks/useUserAuth/useUserAuth.js

@@ -0,0 +1,262 @@
+'use client'
+import { __awaiter } from '../../../../../_virtual/_tslib.js';
+import { DynamicError, MfaInvalidOtpError, EmailAlreadyExistsError, CustomFieldNotUniqueError, UsernameAlreadyExistsError, TooManyEmailVerificationsError, InvalidPhoneNumberError, NoAccessError, AccountExistsError, UserHasAccountWithEmailError, sleep } from '@dynamic-labs/utils';
+import { useAccountExistsContext } from '../../../context/AccountExistsContext/AccountExistsContext.js';
+import 'react';
+import '../../../context/DynamicContext/DynamicContext.js';
+import '@dynamic-labs/sdk-api-core';
+import { logger } from '../../../shared/logger.js';
+import '@dynamic-labs/iconic';
+import '@dynamic-labs/wallet-connector-core';
+import 'react/jsx-runtime';
+import { useViewContext } from '../../../context/ViewContext/ViewContext.js';
+import '@dynamic-labs/wallet-book';
+import '../../constants/colors.js';
+import '../../constants/values.js';
+import '../../../shared/utils/classes/storage/localStorage.js';
+import '../../../shared/consts/index.js';
+import '../../../events/dynamicEvents.js';
+import '../../../context/CaptchaContext/CaptchaContext.js';
+import { useErrorContext } from '../../../context/ErrorContext/ErrorContext.js';
+import '@dynamic-labs/multi-wallet';
+import 'react-international-phone';
+import 'viem';
+import 'viem/chains';
+import '../../../config/ApiEndpoint.js';
+import { storeAuthTokenAndUser } from '../../../store/utils/storeAuthTokenAndUser/storeAuthTokenAndUser.js';
+import { getUserMfaDevices } from '../../../data/api/mfa/mfa.js';
+import '../../../locale/locale.js';
+import '../../../context/AccessDeniedContext/AccessDeniedContext.js';
+import '../../../context/UserWalletsContext/UserWalletsContext.js';
+import '../../../context/VerificationContext/VerificationContext.js';
+import 'react-dom';
+import { useEmbeddedWallet } from '../useEmbeddedWallet/useEmbeddedWallet.js';
+import '../../../context/WalletContext/WalletContext.js';
+import '../../../context/ThemeContext/ThemeContext.js';
+import '../useUserUpdateRequest/useUpdateUser/userFieldsSchema.js';
+import '@dynamic-labs/types';
+import { useLoadingContext } from '../../../context/LoadingContext/LoadingContext.js';
+import { useHandleVerifiedUser } from '../useHandleVerifiedUser/useHandleVerifiedUser.js';
+import 'yup';
+import '../../../context/MockContext/MockContext.js';
+import '../../../views/CollectUserDataView/useFields.js';
+import '../../../context/FieldsStateContext/FieldsStateContext.js';
+import '../../../context/UserFieldEditorContext/UserFieldEditorContext.js';
+import '@dynamic-labs/store';
+import '@dynamic-labs/rpc-providers';
+import 'react-i18next';
+import '../../../components/Alert/Alert.js';
+import '../../../components/ShadowDOM/ShadowDOM.js';
+import '../../../components/IconButton/IconButton.js';
+import '../../../components/InlineWidget/InlineWidget.js';
+import '../../../components/Input/Input.js';
+import '../../../components/IsBrowser/IsBrowser.js';
+import '../../../components/MenuList/Dropdown/Dropdown.js';
+import '../../../components/Transition/ZoomTransition/ZoomTransition.js';
+import '../../../components/Transition/SlideInUpTransition/SlideInUpTransition.js';
+import '../../../components/Transition/OpacityTransition/OpacityTransition.js';
+import '../../../components/OverlayCard/OverlayCardTarget/OverlayCardTarget.js';
+import '../../../components/PasskeyCreatedSuccessBanner/PasskeyCreatedSuccessBanner.js';
+import '../../../components/Popper/Popper/Popper.js';
+import '../../../components/Popper/PopperContext/PopperContext.js';
+import 'react-focus-lock';
+import 'qrcode';
+import 'formik';
+import '../../../views/WalletList/WalletList.js';
+import '../../../context/SocialRedirectContext/SocialRedirectContext.js';
+import '../../../widgets/DynamicBridgeWidget/views/WalletsView/components/SecondaryWallets/SecondaryWallets.js';
+import '@hcaptcha/react-hcaptcha';
+import '../../../context/FooterAnimationContext/index.js';
+import '../../../views/LoginView/sections/PhoneNumberSignInSection/PhoneNumberSignInSection.js';
+import '../../../context/WalletGroupContext/WalletGroupContext.js';
+import '../../../context/MfaSettingsContext/MfaSettingsContext.js';
+import '../../../context/IpConfigurationContext/IpConfigurationContext.js';
+import '../../../context/PasskeyContext/PasskeyContext.js';
+import '../../../widgets/DynamicWidget/components/DynamicWidgetHeader/DynamicWidgetHeader.js';
+import '../../../widgets/DynamicWidget/context/DynamicWidgetContext.js';
+import '../../../views/TransactionConfirmationView/helpers/transactionErrorMessage.js';
+import '../../../widgets/DynamicWidget/views/ManagePasskeysWidgetView/PasskeyCard/PasskeyCard.js';
+import { useInternalDynamicContext } from '../../../context/DynamicContext/useDynamicContext/useInternalDynamicContext.js';
+
+const sleepToShowSuccessMessage = () => sleep(1500);
+const useUserAuth = ({ authMethod, }) => {
+    const { handleLogOut, setShowAuthFlow, setCallback, setMultiWalletWidgetState, environmentId, } = useInternalDynamicContext();
+    const { view, setView, goToInitialView } = useViewContext();
+    const { setLoading } = useLoadingContext();
+    const { setErrorMessage, setError } = useErrorContext();
+    const { setExistentAccountData } = useAccountExistsContext();
+    const handleVerifiedUser = useHandleVerifiedUser();
+    const { shouldAutoCreateEmbeddedWallet } = useEmbeddedWallet();
+    const isVerifyResponse = (response) => response.user;
+    const initAuth = (_a) => __awaiter(void 0, [_a], void 0, function* ({ isSignIn = true, verifyFunction, onVerifySuccess, onSettled, onError, showSuccessMessage = false, skipDefaultErrorHandling = false, }) {
+        var _b, _c;
+        logger.debug('initAuth', { authMethod, isSignIn });
+        try {
+            // TODO: change this logic to const verifiedUser = await verifyFunction();
+            // once all verify functions are updated to return UserProfile instead of VerifyResponse
+            const verifyResponse = yield verifyFunction();
+            if (!verifyResponse) {
+                yield cancelAuth();
+                throw new DynamicError('No user returned from verify function');
+            }
+            let verifiedUser;
+            if (isVerifyResponse(verifyResponse)) {
+                verifiedUser = storeAuthTokenAndUser(verifyResponse);
+            }
+            else {
+                verifiedUser = verifyResponse;
+            }
+            onVerifySuccess === null || onVerifySuccess === void 0 ? void 0 : onVerifySuccess(verifiedUser);
+            if ((_b = verifiedUser.scope) === null || _b === void 0 ? void 0 : _b.includes('requiresAdditionalAuth')) {
+                const devices = yield getUserMfaDevices({ environmentId });
+                if (devices.length === 0) {
+                    setView('mfa-choose-device');
+                }
+                else {
+                    setView('mfa-verification');
+                }
+                return;
+            }
+            if (isSignIn && ((_c = verifiedUser.missingFields) === null || _c === void 0 ? void 0 : _c.length)) {
+                //onboarding will be handled in the onboarding flow
+                return;
+            }
+            setMultiWalletWidgetState('idle');
+            yield handleVerifiedUser(verifiedUser);
+            if (showSuccessMessage) {
+                // this timeout is set to make sure that the user will see success message
+                yield sleepToShowSuccessMessage();
+            }
+            if (isSignIn) {
+                setCallback('authSuccess');
+            }
+            // we should only close auth flow if no wallet is going to be created,
+            // otherwise there will be a glitch with auth flow closing and then reopening for passkeys
+            const shouldCreateWallet = shouldAutoCreateEmbeddedWallet();
+            if (!shouldCreateWallet) {
+                setShowAuthFlow(false);
+            }
+            onSettled === null || onSettled === void 0 ? void 0 : onSettled();
+        }
+        catch (error) {
+            logger.debug(error);
+            if (skipDefaultErrorHandling) {
+                onError === null || onError === void 0 ? void 0 : onError(error);
+                return;
+            }
+            handleAuthError(error, { onError });
+        }
+        finally {
+            setLoading(false);
+            onSettled === null || onSettled === void 0 ? void 0 : onSettled();
+        }
+    });
+    const handleAuthError = (error, { options = {}, onError, }) => {
+        if (error instanceof MfaInvalidOtpError) {
+            throw error;
+        }
+        // these get caught in onboarding form and handled there
+        if (error instanceof EmailAlreadyExistsError ||
+            error instanceof CustomFieldNotUniqueError ||
+            error instanceof UsernameAlreadyExistsError ||
+            error instanceof TooManyEmailVerificationsError ||
+            error instanceof InvalidPhoneNumberError)
+            throw error;
+        if (error instanceof NoAccessError) {
+            setView('no-access');
+            return;
+        }
+        if (error instanceof AccountExistsError) {
+            setExistentAccountData(error.errorPayload);
+            setView('account-exists');
+            return;
+        }
+        // Handle the case where the user has already an account with the email
+        if (error instanceof UserHasAccountWithEmailError) {
+            setView('merge-user-accounts-with-same-email', {
+                returnToView: 'isEmailRecoveryFlow' in options && options.isEmailRecoveryFlow
+                    ? 'passkey-recovery-add-email'
+                    : undefined,
+            });
+            return;
+        }
+        if (onError) {
+            onError === null || onError === void 0 ? void 0 : onError(error);
+            return;
+        }
+        if (error.code) {
+            setErrorMessage(error.code);
+        }
+        else {
+            setError(error.message);
+        }
+    };
+    const handleVerifyMissingFields = (_d) => __awaiter(void 0, [_d], void 0, function* ({ missingFields, isEmailVerificationRequired, isSmsVerificationRequired, }) {
+        if (isEmailVerificationRequired &&
+            missingFields.find((field) => field.name === 'email')) {
+            setView('verify-email');
+            return;
+        }
+        if (isSmsVerificationRequired &&
+            missingFields.find((field) => field.name === 'phoneNumber')) {
+            setView('verify-sms');
+            return;
+        }
+        setView(view.type);
+    });
+    const completeAuth = (_e) => __awaiter(void 0, [_e], void 0, function* ({ completeSignInFlow, updateJwtFunction, onValidUpdatedJwt, options = {}, }) {
+        logger.debug('completeAuth', { authMethod });
+        try {
+            const { updateUserProfileResponse, isSmsVerificationRequired, isEmailVerificationRequired, missingFields, } = yield updateJwtFunction();
+            onValidUpdatedJwt === null || onValidUpdatedJwt === void 0 ? void 0 : onValidUpdatedJwt();
+            const updatedUser = storeAuthTokenAndUser({
+                expiresAt: updateUserProfileResponse.expiresAt,
+                jwt: updateUserProfileResponse.jwt,
+                minifiedJwt: updateUserProfileResponse.minifiedJwt,
+                user: updateUserProfileResponse.user,
+            });
+            if (missingFields.length > 0) {
+                yield handleVerifyMissingFields({
+                    isEmailVerificationRequired,
+                    isSmsVerificationRequired,
+                    missingFields,
+                });
+                return;
+            }
+            yield handleVerifiedUser(updatedUser);
+            setCallback('authSuccess');
+            if (completeSignInFlow) {
+                const shouldReturn = yield completeSignInFlow(updateUserProfileResponse);
+                if (shouldReturn) {
+                    return;
+                }
+            }
+            // we should only close auth flow if no wallet is going to be created,
+            // otherwise there will be a glitch with auth flow closing and then reopening for passkeys
+            const shouldCreateWallet = shouldAutoCreateEmbeddedWallet();
+            if (!shouldCreateWallet) {
+                setShowAuthFlow(false);
+            }
+        }
+        catch (error) {
+            logger.debug(error);
+            handleAuthError(error, { options });
+        }
+        finally {
+            setLoading(false);
+        }
+    });
+    const cancelAuth = () => __awaiter(void 0, void 0, void 0, function* () {
+        logger.debug('cancelAuth', { authMethod });
+        yield handleLogOut();
+        goToInitialView();
+    });
+    return {
+        cancelAuth,
+        completeAuth,
+        handleAuthError,
+        initAuth,
+    };
+};
+
+export { useUserAuth };

package/src/lib/utils/hooks/useUserAuth/useUserAuth.types.d.ts

@@ -0,0 +1,69 @@
+import { UpdateSelfResponse, VerifyResponse } from '@dynamic-labs/sdk-api-core';
+import { AuthMethod, AuthOptions } from '@dynamic-labs/types';
+import { UserProfile } from '../../../..';
+import { UpdateUserReturnPayload } from '../useUserUpdateRequest';
+export type UseUserAuthOptions = {
+    [K in AuthMethod]: Partial<AuthOptions[K]>;
+};
+export type OnErrorCallback = (error: unknown) => void;
+export type OnSettledCallback = () => void;
+export type UseUserAuthProps<T extends AuthMethod> = {
+    authMethod?: T;
+};
+export type InitUserAuthProps<T extends AuthMethod> = {
+    /**
+     * Mainly used for wallet auth.
+     * Indicates if the user is signing in or just linking.
+     */
+    isSignIn?: boolean;
+    /**
+     * Api call that will be made to verify the user.
+     */
+    verifyFunction: () => Promise<UserProfile | VerifyResponse | undefined>;
+    /**
+     * Optional callback that will be called with the new jwt right after the user is verified.
+     */
+    onVerifySuccess?: (user?: UserProfile) => void;
+    /**
+     * Optional callback that will be called whenever initAuth finishes (either successfully or not).
+     */
+    onSettled?: OnSettledCallback;
+    /**
+     * Optional callback that will be called whenever there is an error with initAuth.
+     */
+    onError?: OnErrorCallback;
+    /**
+     * Whether to show a success message after the user is verified or not.
+     * If true, it will wait for 2 seconds before hidding the success message and continuing.
+     */
+    showSuccessMessage?: boolean;
+    /**
+     * If true, it will skip the default error handling and just call the onError callback.
+     */
+    skipDefaultErrorHandling?: boolean;
+    /**
+     * Props specific to the auth method.
+     * (e.g. isRecoveryFlow for email auth, provider for social auth, etc.)
+     */
+    options?: UseUserAuthOptions[T];
+};
+export type CompleteUserAuthProps<T extends AuthMethod> = {
+    /**
+     * Optional function specific to each auth method that should be called to complete the auth flow
+     * after onboarding is completed.
+     */
+    completeSignInFlow?: (updateUserProfileResponse: UpdateSelfResponse) => Promise<boolean>;
+    /**
+     * Api call that will be made to update the user to complete the auth and return a UpdateUserReturnPayload.
+     */
+    updateJwtFunction: () => Promise<UpdateUserReturnPayload>;
+    /**
+     * Optional callback that will be called whenever updateJwtFunction completes successfuly.
+     */
+    onValidUpdatedJwt?: () => void;
+    /**
+     * Props specific to the auth method.
+     * (e.g. isRecoveryFlow for email auth, provider for social auth, etc.)
+     */
+    options?: UseUserAuthOptions[T];
+};

package/src/lib/utils/hooks/useUserDataForm/useUserDataForm.cjs

@@ -6,9 +6,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _tslib = require('../../../../../_virtual/_tslib.cjs');
 var React = require('react');
 var yup = require('yup');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
 var utils = require('@dynamic-labs/utils');
 var MockContext = require('../../../context/MockContext/MockContext.cjs');
-require('@dynamic-labs/sdk-api-core');
 var logger = require('../../../shared/logger.cjs');
 require('@dynamic-labs/iconic');
 require('@dynamic-labs/wallet-connector-core');
@@ -31,25 +31,59 @@ const useUserDataForm = ({ onSubmit, onError, userProfile, shouldEnforcePolicies
     const { fieldsConfig } = useFields.useFields();
     const enforcePolicies = shouldEnforcePolicies &&
         ((_a = fields.find((setting) => setting.name === 'policiesConsent')) === null || _a === void 0 ? void 0 : _a.enabled);
-    const formikValidationSchema = React.useMemo(() => yup.object().shape(Object.fromEntries(fields.map(({ name, required }) => [
-        name,
-        required
-            ? index.getValueByKey(fieldsConfig, name).validation.required('required')
-            : index.getValueByKey(fieldsConfig, name).validation,
-    ]))), [fields]);
-    const formikInitialValues = React.useMemo(() => Object.fromEntries(fields.map(({ name }) => {
-        var _a, _b, _c;
+    const requiredTitleCase = (name) => `${name.charAt(0).toUpperCase() + name.slice(1)} is required`;
+    const formikValidationSchema = React.useMemo(() => yup.object().shape(Object.fromEntries(fields.map(({ name, required, type, validationType, validationRules }) => {
+        let schema = type === sdkApiCore.KycFieldType.Custom
+            ? index.getValueByKey(useFields.customFieldValidationMap, validationType)
+            : index.getValueByKey(fieldsConfig, name).validation;
+        if (type === sdkApiCore.KycFieldType.Custom &&
+            validationRules &&
+            (validationType === sdkApiCore.CustomFieldType.Select ||
+                validationType === sdkApiCore.CustomFieldType.Text)) {
+            schema = schema;
+            if (validationRules.validOptions) {
+                schema = schema.oneOf(validationRules.validOptions.map((option) => option.label), 'Select a valid option');
+            }
+            else if (validationRules.regex) {
+                schema = schema.matches(new RegExp(validationRules.regex), 'Invalid field format');
+            }
+        }
+        return [
+            name,
+            required ? schema.required(requiredTitleCase(name)) : schema,
+        ];
+    }))), [fields]);
+    const formikInitialValues = React.useMemo(() => Object.fromEntries(fields.map(({ name, type, validationRules, validationType }) => {
+        var _a, _b, _c, _d;
         const info = (userProfile !== null && userProfile !== void 0 ? userProfile : {});
+        if (type === sdkApiCore.KycFieldType.Custom) {
+            let defaultValue = '';
+            if (validationType === sdkApiCore.CustomFieldType.Select &&
+                (validationRules === null || validationRules === void 0 ? void 0 : validationRules.validOptions))
+                defaultValue = (_a = validationRules.validOptions[0].label) !== null && _a !== void 0 ? _a : '';
+            return [
+                name,
+                (() => {
+                    var _a;
+                    const value = index.getValueByKey(info.metadata, name);
+                    return Array.isArray(value)
+                        ? value
+                        : (_a = value === null || value === void 0 ? void 0 : value.toString()) !== null && _a !== void 0 ? _a : defaultValue;
+                })(),
+            ];
+        }
         const mapNameToDefaultValue = {
             country: index$1.countryCodes[0].code,
             policiesConsent: false,
             tShirtSize: index$1.tShirtSizes[0],
             team: index$1.teamNames[0],
         };
-        const defaultValue = (_a = mapNameToDefaultValue[name]) !== null && _a !== void 0 ? _a : '';
-        return [name, (_c = (_b = index.getValueByKey(info, name)) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : defaultValue];
+        const defaultValue = (_b = mapNameToDefaultValue[name]) !== null && _b !== void 0 ? _b : '';
+        return [name, (_d = (_c = index.getValueByKey(info, name)) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : defaultValue];
     })) || {}, [fields, userProfile]);
     const onFormSubmit = React.useCallback((values, formikHelper) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const metadata = {};
+        const uniqueMetadata = {};
         if (mockedSDK)
             return;
         try {
@@ -57,6 +91,18 @@ const useUserDataForm = ({ onSubmit, onError, userProfile, shouldEnforcePolicies
                 throw new utils.DynamicError('Invalid environment ID');
             setFetch(true);
             let updatedUserFields = values;
+            // all kyc fields including custom are in the object, move custom fields to the object.metadata
+            Object.entries(updatedUserFields).forEach(([fieldName, fieldValue]) => {
+                const field = fields.find((f) => f.name === fieldName && f.type === sdkApiCore.KycFieldType.Custom);
+                if (field) {
+                    metadata[fieldName] = fieldValue;
+                    delete updatedUserFields[fieldName];
+                    if (field.unique)
+                        uniqueMetadata[fieldName] = fieldValue;
+                }
+            });
+            if (Object.keys(metadata).length > 0)
+                updatedUserFields.metadata = metadata;
             if (enforcePolicies) {
                 updatedUserFields = Object.assign(Object.assign({}, updatedUserFields), { policiesConsent: true });
                 delete updatedUserFields.policiesConsentArray;
@@ -69,6 +115,18 @@ const useUserDataForm = ({ onSubmit, onError, userProfile, shouldEnforcePolicies
             if (e instanceof utils.EmailAlreadyExistsError) {
                 formikHelper.setErrors({ email: 'Email already exists' });
             }
+            else if (e instanceof utils.CustomFieldNotUniqueError) {
+                // clear all non error fields because user has to edit them anyways for the validation to pass, not sure why
+                formikHelper.setFormikState((state) => (Object.assign(Object.assign({}, state), { errors: Object.fromEntries(Object.entries(uniqueMetadata).map(([customFieldName]) => [
+                        customFieldName,
+                        Object.entries(uniqueMetadata).length > 1
+                            ? 'One or more fields are already tied to another user'
+                            : `${customFieldName} is already tied to another user`,
+                    ])), touched: Object.fromEntries(Object.entries(uniqueMetadata).map(([fieldName]) => [
+                        fieldName,
+                        true,
+                    ])), values: Object.assign(Object.assign({}, formikInitialValues), uniqueMetadata) })));
+            }
             else if (e instanceof utils.TooManyEmailVerificationsError) {
                 formikHelper.setErrors({
                     email: 'Too many email verification attempts.',
@@ -78,7 +136,7 @@ const useUserDataForm = ({ onSubmit, onError, userProfile, shouldEnforcePolicies
                 formikHelper.setErrors({ username: 'Username already exists' });
             }
             else if (e instanceof utils.InvalidPhoneNumberError) {
-                formikHelper.setErrors({ phoneNumber: 'Invalid phone number' });
+                formikHelper.setErrors({ phoneNumber: e.message });
             }
             else {
                 formikHelper.setErrors({
@@ -89,7 +147,15 @@ const useUserDataForm = ({ onSubmit, onError, userProfile, shouldEnforcePolicies
         finally {
             setFetch(false);
         }
-    }), [mockedSDK, userProfile === null || userProfile === void 0 ? void 0 : userProfile.environmentId, enforcePolicies, onSubmit, onError]);
+    }), [
+        mockedSDK,
+        userProfile === null || userProfile === void 0 ? void 0 : userProfile.environmentId,
+        enforcePolicies,
+        onSubmit,
+        fields,
+        onError,
+        formikInitialValues,
+    ]);
     return {
         enforcePolicies,
         fetch,

package/src/lib/utils/hooks/useUserDataForm/useUserDataForm.d.ts

@@ -1,3 +1,4 @@
+import { StringSchema } from 'yup';
 import { FormikHelpers } from 'formik';
 import { ProjectSettingsKyc } from '@dynamic-labs/sdk-api-core';
 import { UserProfile } from '@dynamic-labs/types';
@@ -6,6 +7,7 @@ export type UserDataFormValues = {
     policiesConsent?: boolean;
     policiesConsentArray?: [];
     username?: string;
+    metadata?: object;
 };
 export type UseUserDataFormProps = {
     fields: ProjectSettingsKyc[];
@@ -21,17 +23,18 @@ export declare const useUserDataForm: ({ onSubmit, onError, userProfile, shouldE
         [k: string]: string;
     };
     formikValidationSchema: import("yup").ObjectSchema<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
-        [k: string]: import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined>;
+        [k: string]: import("yup/lib/array").OptionalArraySchema<import("yup").AnySchema, import("yup/lib/types").AnyObject, any[] | undefined> | StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined> | import("yup/lib/array").RequiredArraySchema<import("yup").AnySchema, import("yup/lib/types").AnyObject, any[] | undefined>;
     }>, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
-        [k: string]: import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined>;
+        [k: string]: import("yup/lib/array").OptionalArraySchema<import("yup").AnySchema, import("yup/lib/types").AnyObject, any[] | undefined> | StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined> | import("yup/lib/array").RequiredArraySchema<import("yup").AnySchema, import("yup/lib/types").AnyObject, any[] | undefined>;
     }>>, import("yup/lib/object").AssertsShape<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
-        [k: string]: import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined>;
+        [k: string]: import("yup/lib/array").OptionalArraySchema<import("yup").AnySchema, import("yup/lib/types").AnyObject, any[] | undefined> | StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined> | import("yup/lib/array").RequiredArraySchema<import("yup").AnySchema, import("yup/lib/types").AnyObject, any[] | undefined>;
     }>>>;
     onFormSubmit: (values: {
         email?: string;
         policiesConsent?: boolean;
         policiesConsentArray?: [];
         username?: string;
+        metadata?: object;
     }, formikHelper: FormikHelpers<{
         api?: string;
         email?: string;