@adyen/kyc-components 3.50.2 → 3.51.1

package/dist/types/{utils/trustMembers/handlers → components/Trust/utils}/updateExemptSettlorName.d.ts

@@ -1,5 +1,5 @@
-import type { DropinAPIHandlers } from '../../../components/Dropins/types';
-import type { ExemptSettlor } from '../../../components/TrustMembers/types';
+import type { DropinAPIHandlers } from '../../Dropins/types';
+import type { ExemptSettlor } from '../tasks/TrustMembers/types';
 import type { ExistingLegalEntity } from '../../../core/models/api/legal-entity';
 export declare const exemptSettlorNamesTheSame: (existingSettlor: ExemptSettlor, newSettlor: ExemptSettlor) => boolean;
 export declare const updateExemptSettlorName: ({ exemptSettlor, handleUpdateLegalEntity, }: {

package/dist/types/components/index.d.ts

@@ -2,14 +2,13 @@ import type { CoreProviderProps } from '../core/context/CoreProvider';
 import type { ExperimentsProps } from '../core/context/ExperimentContext/types';
 import type { SettingsProps } from '../core/context/SettingsContext/types';
 import type { UserEventCallback } from '../core/user-events';
-import { BusinessDetailsDropin } from './Dropins/BusinessDetailsDropin/BusinessDetailsDropin';
-import { CompanyDropin } from './Dropins/CompanyDropin/CompanyDropin';
+import { BusinessDetailsDropin } from './Business/tasks/BusinessDetailsDropin/BusinessDetailsDropin';
+import { CompanyDropin } from './Business/tasks/CompanyDropin/CompanyDropin';
 import { DropinComposer } from './Dropins/DropinComposer/DropinComposer';
 import { IndividualDropin } from './Dropins/IndividualDropin/IndividualDropin';
-import { PayoutDetailsDropin } from './Dropins/PayoutDetailsDropin/PayoutDetailsDropin';
 import { PciDropin } from './Dropins/PciDropin/PciDropin';
-import { SolePropDropin } from './Dropins/SolePropDropin/SolePropDropin';
-import { TrustDropin } from './Dropins/TrustDropin/TrustDropin';
+import { SolePropDropin } from './SoleProprietorship/tasks/SolePropDropin/SolePropDropin';
+import { TrustDropin } from './Trust/tasks/TrustDropin/TrustDropin';
 import { AcceptTermsOfServiceComponent } from './EmbeddedDropins/AcceptTermsOfServiceComponent/AcceptTermsOfServiceComponent';
 import { CreateIndividualComponent } from './EmbeddedDropins/CreateIndividualComponent/CreateIndividualComponent';
 import { CreateTransferInstrumentComponent } from './EmbeddedDropins/CreateTransferInstrumentComponent/CreateTransferInstrumentComponent';
@@ -23,6 +22,7 @@ import { UpdateLegalEntityForHighExposure } from './EmbeddedDropins/UpdateLegalE
 import { ViewVerificationStatusComponent } from './EmbeddedDropins/ViewVerificationStatus/ViewVerificationStatusComponent';
 import type { EventEmitter } from '../core/EventEmitter';
 import { SourceOfFundsDropin } from './Dropins/SourceOfFundsDropin/SourceOfFundsDropin';
+import { PayoutDetailsDropin } from './BankAccount/tasks/PayoutDetailsDropin/PayoutDetailsDropin';
 /**
  * Maps each component with a Component element.
  */

package/dist/types/components/ui/atoms/Svg/svgs.d.ts

@@ -19,7 +19,7 @@ export declare const icons: {
     check: import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     certificate: import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     checkmark: import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
-    'checkmark-circle-fill': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
+    'checkmark-circle': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     'checkmark-small': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     'chevron-down': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     'chevron-right': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
@@ -146,7 +146,7 @@ export declare const svgs: {
     readonly check: import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     readonly certificate: import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     readonly checkmark: import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
-    readonly 'checkmark-circle-fill': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
+    readonly 'checkmark-circle': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     readonly 'checkmark-small': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     readonly 'chevron-down': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;
     readonly 'chevron-right': import("preact").FunctionComponent<import("preact").JSX.SVGAttributes<SVGSVGElement>>;

package/dist/types/components/ui/molecules/Dropzone/types.d.ts

@@ -16,6 +16,10 @@ export interface DropzoneProps extends Partial<FileValidationOptions> {
     shouldValidate?: boolean;
     showMinimal?: boolean;
     hidePageCount?: boolean;
+    errors?: any;
+    fieldValidationErrors?: any;
+    valid?: any;
+    handleFieldChange?: any;
     enableTracking?: boolean;
 }
 export interface DropzoneFileProps {

package/dist/types/core/analytics.d.ts

@@ -1,19 +1,16 @@
 import type { SetOptional } from 'type-fest';
 import type { LegalEntity } from './models/api/legal-entity';
-import type { TaskIdentifier } from '../stores/globalStore/globalStore';
 import type { AdditionalEventProperties } from './user-events';
-type BaseTrackingPayloadParams = {
-    task?: TaskIdentifier;
+type GetAssociatedLeAnalyticsParams = {
     associatedLegalEntity?: LegalEntity;
     associatedLegalEntityOrg?: LegalEntity;
 };
-export type BaseTrackingPayload = {
-    task?: TaskIdentifier;
+export type AssociatedLeAnalyticsParams = {
     associatedLegalEntityId?: string;
     associatedLegalEntityType?: string;
     associatedLegalEntityOrgId?: string;
     associatedLegalEntityOrgType?: string;
 };
-export declare const getAssociatedLeAnalyticsPayload: ({ task, associatedLegalEntity, associatedLegalEntityOrg, }: BaseTrackingPayloadParams) => BaseTrackingPayload;
+export declare const getAssociatedLeAnalyticsPayload: ({ associatedLegalEntity, associatedLegalEntityOrg, }: GetAssociatedLeAnalyticsParams) => AssociatedLeAnalyticsParams;
 export declare const debouncedInputEvent: import("lodash").DebouncedFunc<(properties: SetOptional<AdditionalEventProperties, "actionLevel">) => void>;
 export {};

package/dist/types/core/context/ConfigurationApiContext/ConfigurationApiContext.d.ts

@@ -7,7 +7,7 @@ import type { GetConfigurationRequest, GetConfigurationResponse } from '../../mo
 import type { VerifyIdNumberRequest, VerifyIdNumberResponse } from '../../models/api/verify-id-number';
 import type { CountryCode } from '../../models/country-code';
 import type { AccountValidationResponse, ValidationResponse } from '../../models/errors/validation-error';
-import type { BusinessLinesType, SourceOfFundsPayloadType } from '../../models/api/source-of-funds';
+import type { BusinessLinesType, SourceOfFundsPayloadDataType } from '../../models/api/source-of-funds';
 export type ConfigurationApi = {
     getConfiguration: (request: GetConfigurationRequest) => Promise<GetConfigurationResponse>;
     getAllowedCountries: () => Promise<GetAllowedCountriesResponse>;
@@ -21,6 +21,6 @@ export type ConfigurationApi = {
     getNaceCodes: () => Promise<DataSet>;
     getBusinessLines: (legalEntityId: string) => Promise<BusinessLinesType[]>;
     getSourceOfFundsTypes: () => Promise<DataSet>;
-    updateSourceOfFunds: (businessLineId: string, sourceOfFundData: SourceOfFundsPayloadType) => Promise<BusinessLinesType | undefined>;
+    updateSourceOfFunds: (legalEntityId: string, businessLineId: string, sourceOfFundData: SourceOfFundsPayloadDataType) => Promise<BusinessLinesType | undefined>;
 };
 export declare const ConfigurationApiContext: import("preact").Context<ConfigurationApi>;

package/dist/types/core/context/CoreContext.d.ts

@@ -1,6 +1,6 @@
 import type { AccountHolderOption } from '../types/AccountHolder.types';
-import type { BankAccountFormatType } from '../../components/BankAccountFormat/types';
 import type { CountryCode } from '../models/country-code';
+import type { BankAccountFormatType } from '../../components/BankAccount/fields/BankAccountFormat/types';
 export interface CoreContextType {
     setContextCountry: (country: CountryCode) => void;
     contextCountry: CountryCode;

package/dist/types/core/context/ExperimentContext/types.d.ts

@@ -7,7 +7,6 @@ export declare enum ExperimentNames {
     EnableNewBusinessDetailsFlow = "EnableNewBusinessDetailsFlow",
     EnableKompanySearchByRegistrationNumber = "EnableKompanySearchByRegistrationNumber",
     EnableNewAddressComponent = "EnableNewAddressComponent",
-    EnableNewPhoneField = "EnableNewPhoneField",
     AllowMoreRolesForMainRootTrustee = "AllowMoreRolesForMainRootTrustee",
     ShowUnsupportedEntityType = "ShowUnsupportedEntityType",
     ShowSingPassButtonForCompanies = "ShowSingPassButtonForCompanies",
@@ -30,7 +29,11 @@ export declare enum ExperimentNames {
     ShowCustomerSupportV4 = "ShowCustomerSupportV4",
     EnableRegistrationAndTaxAbsentStatesV4 = "EnableRegistrationAndTaxAbsentStatesV4",
     CredentialBankingWeightage_EmphasizeCredentialBankingFlow = "CredentialBankingWeightage_EmphasizeCredentialBankingFlow",
-    EnableManualCompanyTinVerification = "EnableManualCompanyTinVerification"
+    EnableManualCompanyTinVerification = "EnableManualCompanyTinVerification",
+    EnableAutofillFlowForPureIndividualsInKeyMarkets = "EnableAutofillFlowForPureIndividualsInKeyMarkets",
+    EnableAutofillFlowForPureIndividualsInAdditionalMarkets = "EnableAutofillFlowForPureIndividualsInAdditionalMarkets",
+    EnableAutofillFlowForDecisionMakersInKeyMarkets = "EnableAutofillFlowForDecisionMakersInKeyMarkets",
+    EnableAutofillFlowForDecisionMakersInAdditionalMarkets = "EnableAutofillFlowForDecisionMakersInAdditionalMarkets"
 }
 export type ExperimentName = `${ExperimentNames}`;
 export type Experiments = {

package/dist/types/core/context/FormContext/FormContext.d.ts

@@ -0,0 +1,2 @@
+import type { FormContextValue } from './types';
+export declare const FormContext: import("preact").Context<FormContextValue<import("../StateContext/types").TopLevelDataSchema>>;

package/dist/types/core/context/FormContext/FormContextProvider.d.ts

@@ -0,0 +1,3 @@
+import type { FormContextProps } from './types';
+import type { TopLevelDataSchema } from '../StateContext/types';
+export declare function FormContextProvider<FormSchema extends TopLevelDataSchema>({ children, form, }: FormContextProps<FormSchema>): import("preact").JSX.Element;

package/dist/types/core/context/FormContext/types.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentChildren } from 'preact';
+import type { TopLevelDataSchema } from '../StateContext/types';
+import type { Form } from '../../hooks/useMultiForm/types';
+export interface FormContextProps<FormSchema extends TopLevelDataSchema = TopLevelDataSchema> {
+    children?: ComponentChildren;
+    form: Form<FormSchema>;
+}
+export interface FormContextValue<FormSchema extends TopLevelDataSchema = TopLevelDataSchema> {
+    form?: Form<FormSchema>;
+}

package/dist/types/core/context/FormContext/useFormContext.d.ts

@@ -0,0 +1,3 @@
+import type { FormContextValue } from './types';
+import type { TopLevelDataSchema } from '../StateContext/types';
+export declare function useFormContext<FormSchema extends TopLevelDataSchema>(): FormContextValue<FormSchema>;

package/dist/types/core/context/StateContext/types.d.ts

@@ -1,14 +1,14 @@
-import type { BusinessDetailsSchema } from '../../../components/BusinessDetails/types';
-import type { CompanySchema } from '../../../components/Company/types';
+import type { BusinessDetailsSchema } from '../../../components/Business/forms/BusinessDetails/types';
+import type { CompanySchema } from '../../../components/Business/forms/Company/types';
 import type { CustomerSupportSchema } from '../../../components/CustomerSupport/types';
 import type { HighExposureSchema } from '../../../components/Dropins/HighExposureDropin/types';
-import type { TrustMemberSchema } from '../../../components/Dropins/RoleAndTypeDropin/types';
+import type { TrustMemberSchema } from '../../../components/Trust/tasks/RoleAndTypeDropin/types';
 import type { IndividualSchema } from '../../../components/Individual/types';
-import type { PayoutDetailsSchema } from '../../../components/PayoutDetails/types';
-import type { SolePropSchema } from '../../../components/SoleProp/types';
-import type { TrustSchema } from '../../../components/Trust/types';
+import type { SolePropSchema } from '../../../components/SoleProprietorship/forms/SoleProp/types';
+import type { TrustSchema } from '../../../components/Trust/forms/Trust/types';
 import type { ValidationRuleResult } from '../../../utils/validation/types';
 import type { SourceOfFundsSchema } from '../../../components/Dropins/SourceOfFundsDropin/types';
+import type { PayoutDetailsSchema } from '../../../components/BankAccount/forms/PayoutDetails/types';
 export interface SFValue {
     caller?: string;
     data?: object;
@@ -77,12 +77,12 @@ export interface State<TLDS extends TopLevelDataSchema> {
 }
 export interface StateSlice<TLDS extends TopLevelDataSchema, SliceName extends keyof TLDS, SliceData extends TLDS[SliceName]> {
     data?: SliceData;
-    valid?: {
+    valid?: Partial<{
         [key in keyof SliceData]: boolean;
-    };
-    errors?: {
+    }>;
+    errors?: Partial<{
         [key in keyof SliceData]: ValidationRuleResult | null;
-    };
+    }>;
     fieldProblems?: {
         [key in keyof SliceData]: boolean;
     };

package/dist/types/core/hooks/useBankConfigurationHandlers.d.ts

@@ -1,4 +1,3 @@
-import type { BankVerificationVendor } from '../../components/BankVerification/types';
 import type { DropinAPIHandlers } from '../../components/Dropins/types';
 import type { LoadingStatus } from '../../components/ui/atoms/LoaderWrapper/constants';
 import type { ConfigurationApi } from '../context/ConfigurationApiContext/ConfigurationApiContext';
@@ -6,6 +5,7 @@ import type { CapabilityName } from '../models/api/capability';
 import type { GetConfigurationResponse } from '../models/api/get-configuration';
 import type { LegalEntityType } from '../models/api/legal-entity-type';
 import type { CountryCode } from '../models/country-code';
+import type { BankVerificationVendor } from '../../components/BankAccount/forms/BankVerification/types';
 interface UseBankConfigurationHandlersProps {
     isEmbeddedDropin: boolean;
     handleGetBankVerificationVendors: DropinAPIHandlers['handleGetBankVerificationVendors'];

package/dist/types/core/hooks/useComponentApi.d.ts

@@ -22,7 +22,6 @@ export type ComponentApi = {
     createTrustedTransferInstrument: Required<DropinAPIHandlers>['handleCreateTrustedTransferInstrument'];
     handleBankVerificationError(errorCode: string, errorMessage: string, state: string, metadata?: Map<string, string>): Promise<BankVerificationErrorResponse>;
     getTransferInstruments(): Promise<TransferInstrumentReference[]>;
-    getOnboardingStatus: Required<DropinAPIHandlers>['handleGetOnboardingStatus'];
     generateOnboardingLink: Required<DropinAPIHandlers>['handleGenerateOnboardingLink'];
     getPciStatus: Required<DropinAPIHandlers>['handleGetPciStatus'];
     getPciTemplate: Required<DropinAPIHandlers>['handleGetPciTemplate'];

package/dist/types/core/hooks/useFormComposer.d.ts

@@ -1,7 +1,9 @@
 import type { Dispatch, StateUpdater } from 'preact/hooks';
 import type { EntityProblems } from '../models/errors/entity-problems';
 import type { FormModelWithValidity } from '../models/form';
-import type { BaseTrackingPayload } from '../analytics';
+import type { AdditionalEventProperties } from '../user-events';
+import type { Form } from './useMultiForm/types';
+import type { TopLevelDataSchema } from '../context/StateContext/types';
 export interface FormComposer {
     handleNextClick(): void;
     handleBackClick?(): void;
@@ -14,11 +16,12 @@ export interface FormComposer {
         total: number;
     };
 }
-export declare const useFormComposer: ({ problems, baseTrackingPayload, forms, formRef, externalBackClick, onSubmit, }: {
+export declare const useFormComposer: <Schema extends TopLevelDataSchema = TopLevelDataSchema>({ problems, navigationTrackingParams, forms, externalBackClick, onSubmit, triggerValidation, }: {
     problems?: EntityProblems;
-    baseTrackingPayload: BaseTrackingPayload;
+    navigationTrackingParams?: Partial<AdditionalEventProperties>;
     forms: FormModelWithValidity[];
     formRef?: any;
     externalBackClick?(): void;
     onSubmit(): void;
+    triggerValidation?: Form<Schema>["triggerValidation"];
 }) => FormComposer;

package/dist/types/core/hooks/useMultiForm/reducer.d.ts

@@ -0,0 +1,89 @@
+import type { Reducer } from 'preact/hooks';
+import type { FormatRules, ValidationRuleResult, ValidatorMode } from '../../../utils/validation/types';
+import { ValidationResult } from '../../../utils/validation/validationResult';
+import type { TriggerStaticValidation } from './useMultiFormStaticValidator';
+import type { FieldValue, FormState, MultiFormState, NestedSchema } from './types';
+export interface MultiFormInitOptions<T> {
+    requiredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    staticValidate: TriggerStaticValidation<T>;
+    defaultData?: T;
+    data?: T;
+    asyncErrors?: {
+        [InnerFormName in keyof T]: {
+            [FieldName in keyof T[InnerFormName]]: ValidationResult;
+        };
+    };
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    optionalFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    trustedFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    fieldProblems?: {
+        [InnerFormName in keyof T]: {
+            [FieldName in keyof T[InnerFormName]]: boolean;
+        };
+    };
+    formatters?: {
+        [InnerFormName in keyof T]: FormatRules<T[InnerFormName]>;
+    };
+}
+/**
+ * The function takes in the below params and spits out an initial state, by running the validations
+ * across all forms and fields. It makes sure all validations are done and only sets the validity
+ * instead of the errors, this is to avoid users seeing error immaturely on initial load.
+ *
+ * @param requiredFields
+ * @param staticValidate
+ * @param asyncValidate
+ * @param defaultData
+ * @param obscuredFields
+ * @param optionalFields
+ * @param trustedFields
+ * @param fieldProblems
+ * @param formatters
+ * @param data
+ */
+export declare function init<FormSchema>({ requiredFields, staticValidate, defaultData, obscuredFields, optionalFields, trustedFields, fieldProblems, formatters, data, asyncErrors, }: MultiFormInitOptions<FormSchema>): MultiFormState<FormSchema>;
+export type ReducerActionType = 'setData' | 'setValid' | 'setErrors' | 'updateField' | 'setInnerFormRequiredFields' | 'setRequiredFields' | 'validateForm' | 'setAsyncErrors';
+export interface ReducerAction<FormSchema> {
+    type: ReducerActionType;
+    key?: keyof NestedSchema<FormSchema>;
+    mode?: ValidatorMode;
+    value?: FieldValue<NestedSchema<FormSchema>> | ValidationRuleResult | boolean | null;
+    formName?: keyof FormSchema;
+    innerFormFields?: (keyof NestedSchema<FormSchema>)[];
+    requiredFields?: {
+        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+    };
+    optionalFields?: {
+        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+    };
+    defaultData?: FormSchema;
+    selectedSchema?: (keyof NestedSchema<FormSchema>)[];
+    formValue?: FormState<NestedSchema<FormSchema>>;
+    asyncValidationResults?: Record<keyof NestedSchema<FormSchema>, ValidationResult>;
+}
+export interface GetReducerOptions<T> {
+    staticValidate: TriggerStaticValidation<T>;
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    optionalFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    trustedFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    formatters?: {
+        [InnerFormName in keyof T]: FormatRules<T[InnerFormName]>;
+    };
+    defaultData?: T;
+}
+export type GetReducerResults<FormSchema> = Reducer<MultiFormState<FormSchema>, ReducerAction<FormSchema>>;
+export declare function reducer<FormSchema>({ staticValidate, obscuredFields, optionalFields, trustedFields, formatters, defaultData, }: GetReducerOptions<FormSchema>): GetReducerResults<FormSchema>;

package/dist/types/core/hooks/useMultiForm/types.d.ts

@@ -0,0 +1,151 @@
+import type { Translatable, TranslationKey } from '../../../language/types';
+import type { Mask } from '../../../utils/masking/maskTypes';
+import type { AsyncValidatorRules, FormatRules, ValidationRuleResult, ValidatorMode, ValidatorRules } from '../../../utils/validation/types';
+import type { TrustedFieldsProvider } from '../../models/api/trusted-fields-provider';
+export type FieldData<FieldSchema> = {
+    [fieldData in keyof FieldSchema]: FieldSchema[fieldData];
+};
+export type FieldValid<FieldSchema> = {
+    [fieldValid in keyof FieldSchema]: boolean;
+};
+export type FieldErrors<FieldSchema> = {
+    [fieldError in keyof FieldSchema]: string | boolean;
+};
+export type FieldLabels<FieldSchema> = {
+    [fieldLabel in keyof FieldSchema]?: string;
+};
+export interface MaskSettings {
+    mask?: Mask;
+    transformOnType?: (val: string) => string;
+}
+export type FieldValue<InnerFormSchema> = InnerFormSchema[keyof InnerFormSchema];
+export interface FormState<InnerFormSchema> {
+    schema?: Array<keyof InnerFormSchema>;
+    data: InnerFormSchema;
+    errors: Record<keyof InnerFormSchema, ValidationRuleResult | null>;
+    asyncErrors: Record<keyof InnerFormSchema, ValidationRuleResult | null>;
+    valid: Record<keyof InnerFormSchema, boolean>;
+    fieldProblems: Record<keyof InnerFormSchema, boolean>;
+    obscuredFields?: Array<keyof InnerFormSchema>;
+    optionalFields?: Array<keyof InnerFormSchema>;
+    trustedFields?: Array<string>;
+    isValid?: boolean;
+    dataStoreId?: string;
+    local?: FormState<InnerFormSchema> | Partial<FormState<InnerFormSchema>>;
+}
+export interface Form<T> extends MultiFormState<T> {
+    setData: (key: keyof NestedSchema<T>, value: FieldValue<NestedSchema<T>>, formName: FormName<T>) => void;
+    setValid: (key: keyof NestedSchema<T>, value: boolean, formName: FormName<T>) => void;
+    setErrors: (key: keyof NestedSchema<T>, value: ValidationRuleResult | null, formName: FormName<T>) => void;
+    handleChangeFor<InnerFormName extends keyof T>(key: keyof T[InnerFormName], formName: InnerFormName, mode?: ValidatorMode): (e: any) => void;
+    triggerValidation: (formName: FormName<T>, selectedSchema?: (keyof NestedSchema<T>)[]) => Promise<boolean>;
+    resetToDefaultData: () => void;
+    defaultData?: T;
+}
+export interface BaseFormProps<FormSchema> {
+    placeholders?: {
+        [Field in keyof FormSchema]: TranslationKey;
+    };
+    labels?: {
+        [Field in keyof FormSchema]: TranslationKey;
+    };
+    helperText?: {
+        [Field in keyof FormSchema]: Translatable;
+    };
+    guidanceText?: {
+        [Field in keyof FormSchema]: Translatable;
+    };
+    masks?: {
+        [Field in keyof FormSchema]: MaskSettings;
+    };
+    data?: FormSchema;
+    validators?: ValidatorRules<FormSchema>;
+    ref?: any;
+    heading?: string;
+    name?: string;
+    description?: string;
+    readOnly?: boolean;
+    shouldValidate?: boolean;
+    trustedFieldsProvider?: TrustedFieldsProvider;
+}
+export type FormName<T> = keyof {
+    [InnerFormName in keyof T]: T[InnerFormName];
+};
+export type NestedSchema<T> = T[keyof T];
+export type MultiFormState<T> = {
+    requiredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    data: T;
+    errors: {
+        [InnerFormName in keyof T]: {
+            [FieldName in keyof T[InnerFormName]]: ValidationRuleResult | null;
+        };
+    };
+    asyncErrors: {
+        [InnerFormName in keyof T]: {
+            [FieldName in keyof T[InnerFormName]]: ValidationRuleResult | null;
+        };
+    };
+    valid: {
+        [InnerFormName in keyof T]: {
+            [FieldName in keyof T[InnerFormName]]: boolean;
+        };
+    };
+    fieldProblems: {
+        [InnerFormName in keyof T]: {
+            [FieldName in keyof T[InnerFormName]]: boolean;
+        };
+    };
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    optionalFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    trustedFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    isValid?: {
+        [InnerFormName in keyof T]: boolean;
+    };
+    local?: {
+        [InnerFormName in keyof T]: Partial<FormState<T[InnerFormName]>>;
+    };
+    defaultData?: T;
+};
+export interface MultiFormOptions<T> {
+    requiredFields?: {
+        [InnerFormName in keyof T]: (keyof Required<T[InnerFormName]>)[];
+    } | ((data: T | undefined) => {
+        [InnerFormName in keyof T]: (keyof T[InnerFormName])[];
+    });
+    defaultData?: T;
+    rules?: {
+        [InnerFormName in keyof T]: ValidatorRules<T[InnerFormName]>;
+    } | ((data?: T) => {
+        [InnerFormName in keyof T]: ValidatorRules<T[InnerFormName]>;
+    });
+    asyncRules?: {
+        [InnerFormName in keyof T]: AsyncValidatorRules<T[InnerFormName]>;
+    } | ((data?: T) => {
+        [InnerFormName in keyof T]: AsyncValidatorRules<T[InnerFormName]>;
+    });
+    formatters?: {
+        [InnerFormName in keyof T]: FormatRules<T[InnerFormName]>;
+    };
+    fieldProblems?: {
+        [InnerFormName in keyof T]: {
+            [FieldName in keyof T[InnerFormName]]: boolean;
+        };
+    };
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    optionalFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+    trustedFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
+}

package/dist/types/core/hooks/useMultiForm/useMultiForm.d.ts

@@ -0,0 +1,2 @@
+import type { Form, MultiFormOptions } from './types';
+export declare function useMultiForm<FormSchema>({ requiredFields, defaultData, rules, asyncRules, fieldProblems, obscuredFields, optionalFields, trustedFields, formatters, }: MultiFormOptions<FormSchema>): Form<FormSchema>;

package/dist/types/core/hooks/useMultiForm/useMultiFormAsyncValidator.d.ts

@@ -0,0 +1,16 @@
+import type { AsyncValidatorRules } from '../../../utils/validation/types';
+import { ValidationResult } from '../../../utils/validation/validationResult';
+import type { MultiFormState } from './types';
+export type TriggerAsyncValidation<FormSchema, InnerFormName extends keyof FormSchema> = (field: keyof FormSchema[InnerFormName], formName: InnerFormName, data?: FormSchema) => Promise<ValidationResult>;
+export type UseAsyncValidator<FormSchema> = {
+    triggerAsyncFormValidation: <InnerFormName extends keyof FormSchema>(formName: InnerFormName, state: MultiFormState<FormSchema>, selectedSchema?: (keyof FormSchema[InnerFormName])[]) => Promise<Record<keyof FormSchema[InnerFormName], ValidationResult> & {
+        isValid: boolean;
+    }>;
+};
+/**
+ * Returns
+ * - triggerAsyncValidation function which can execute the async validation for a field and populate the sync validation results
+ * - asyncValidationResult state which keeps track of async validations of all fields.
+ * @param asyncRules
+ */
+export declare const useMultiFormAsyncValidator: <T>(asyncRules?: { [InnerFormName in keyof T]: AsyncValidatorRules<T[InnerFormName]>; } | ((data?: T) => { [InnerFormName in keyof T]: AsyncValidatorRules<T[InnerFormName]>; })) => UseAsyncValidator<T>;

package/dist/types/core/hooks/useMultiForm/useMultiFormStaticValidator.d.ts

@@ -0,0 +1,8 @@
+import type { FieldContext, FieldData } from '../../../utils/validation/types';
+import { ValidationResult } from '../../../utils/validation/validationResult';
+import type { MultiFormOptions, NestedSchema } from './types';
+export type TriggerStaticValidation<FormSchema> = (fieldData: FieldData<NestedSchema<FormSchema>>, data?: FormSchema, context?: FieldContext<NestedSchema<FormSchema>>) => ValidationResult;
+export type UseStaticValidator<FormSchema> = {
+    triggerStaticValidation: TriggerStaticValidation<FormSchema>;
+};
+export declare const useMultiFormStaticValidator: <T>(rules?: MultiFormOptions<T>["rules"]) => UseStaticValidator<T>;

package/dist/types/core/hooks/useMultiForm/utils.d.ts

@@ -0,0 +1,13 @@
+import type { FieldData } from './types';
+export declare const omitKeys: (obj: any, omit: any) => any;
+export declare const addKeys: (obj: any, add: any, initialValue: any, defaultData: any, pendingData: any) => any;
+/**
+ * @description Extracts the field schema data from the form schema using the field component
+ *
+ * @param formData The data of the form using the field component
+ * @param fieldKeys The keys in the field schema
+ * @returns An object containing only the field schemas form data
+ */
+export declare function getDataByFields<FormSchema, Fields extends Array<keyof FormSchema>, FieldSchema extends {
+    [field in keyof FormSchema]: FormSchema[field];
+}>(formData: FormSchema, fieldKeys: Fields): FieldData<FieldSchema>;

package/dist/types/core/hooks/useScenarioConfiguration.d.ts

@@ -1,10 +1,10 @@
 import type { Dispatch, StateUpdater } from 'preact/hooks';
-import type { BankAccountFormatType } from '../../components/BankAccountFormat/types';
 import type { LoadingStatus } from '../../components/ui/atoms/LoaderWrapper/constants';
 import type { AccountFormatRequirements, PayoutAccountFormats } from '../../datasets/accountFormats/getAccountFormatForCountry';
 import type { GetConfigurationResponse } from '../models/api/get-configuration';
 import type { CountryCode } from '../models/country-code';
 import type { FieldConfigurations } from '../models/field-configurations';
+import type { BankAccountFormatType } from '../../components/BankAccount/fields/BankAccountFormat/types';
 export type ParseConfiguration = (configuration: GetConfigurationResponse & {
     requiredFields: AccountFormatRequirements | undefined;
     bankVerificationAvailable?: boolean;

package/dist/types/core/models/api/get-bankVerification-providers.d.ts

@@ -1,2 +1,2 @@
-import type { BankVerificationVendor } from '../../../components/BankVerification/types';
+import type { BankVerificationVendor } from '../../../components/BankAccount/forms/BankVerification/types';
 export type BankVerificationVendorsResponse = BankVerificationVendor[];

package/dist/types/core/models/api/get-configuration.d.ts

@@ -1,9 +1,9 @@
-import type { BankVerificationVendor, CountryBankVerificationVendors } from '../../../components/BankVerification/types';
 import type { TaskTypes } from '../../../components/TaskList/types';
 import type { CountryCode } from '../country-code';
 import type { CapabilityName } from './capability';
 import type { GetScenariosResponse } from './get-scenarios';
 import type { LegalEntityType } from './legal-entity-type';
+import type { BankVerificationVendor, CountryBankVerificationVendors } from '../../../components/BankAccount/forms/BankVerification/types';
 export interface GetConfigurationRequest {
     country: CountryCode;
     capabilities?: CapabilityName[];

package/dist/types/core/models/api/legal-entity-association.d.ts

@@ -1,4 +1,4 @@
-import type { SettlorExemptionReason } from '../../../components/TrustRoleAndEntityType/types';
+import type { SettlorExemptionReason } from '../../../components/Trust/forms/TrustRoleAndEntityType/types';
 import type { DecisionMakerType } from './decision-maker-type';
 import type { LegalEntityType } from './legal-entity-type';
 import type { TrustMemberType } from './trust-member-type';

package/dist/types/core/models/api/source-of-funds.d.ts

@@ -32,6 +32,10 @@ export interface SourceOfFundsType {
 export interface SourceOfFundsPayloadType extends Omit<SourceOfFundsType, 'legalName' | 'country' | 'firstName' | 'lastName' | 'originatorType'> {
     adyenProcessedFunds: boolean;
 }
+export interface SourceOfFundsPayloadDataType {
+    sourceOfFunds: SourceOfFundsPayloadType;
+    legalEntityId: string;
+}
 export interface SourceOfFundsAmount {
     currency: Currency;
     value: number;

package/dist/types/core/models/api/trusted-transferInstrument.d.ts

@@ -1,4 +1,4 @@
-import type { AccountVerificationResponse } from '../../../components/BankVerification/types';
+import type { AccountVerificationResponse } from '../../../components/BankAccount/forms/BankVerification/types';
 export type CreateTrustedTransferInstrumentResponse = {
     verificationReference: string;
     accounts: AccountVerificationResponse[];

package/dist/types/core/models/payout-account.d.ts

@@ -1,7 +1,7 @@
-import type { BankAccountFormatType } from '../../components/BankAccountFormat/types';
-import type { PayoutAccountSchema } from '../../components/PayoutAccount/types';
 import type { CountryCode } from './country-code';
 import type { CountryConfig } from './country-config';
+import type { PayoutAccountSchema } from '../../components/BankAccount/forms/PayoutAccount/types';
+import type { BankAccountFormatType } from '../../components/BankAccount/fields/BankAccountFormat/types';
 export declare const obscuredPayoutFields: Array<keyof PayoutAccountSchema>;
 export declare const countryConfig: CountryConfig;
 export declare const defaultPayoutAccountFormat: Partial<Record<CountryCode, BankAccountFormatType>>;