@adyen/kyc-components 3.79.0 → 3.80.0-beta.0

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

@@ -2,21 +2,21 @@
  * @description These are the available scenarios matching the API
  * kycexternalapi/src/main/java/com/adyen/services/kycexternalapi/entity/Scenario.java
  */
-export declare const enum Scenarios {
-    L = "L",
-    L0 = "L0",
-    L1 = "L1",
-    L1_ID = "L1_ID",
-    L1_IDO = "L1_IDO",
-    L1_NAT = "L1_NAT",
-    L1_IDDOC = "L1_IDDOC",
-    L2 = "L2",
-    L_REGDOC = "L_REGDOC",
-    L_TAXDOC = "L_TAXDOC",
-    L_PROOFOFADDRESS = "L_PROOFOFADDRESS",
-    L_PH = "L_PH",
-    L_MOTION = "L_MOTION",
-    L_TAXINFO = "L_TAXINFO",
-    L_BAFIN = "L_BAFIN"
-}
-export type Scenario = `${Scenarios}`;
+export declare const Scenarios: {
+    readonly L: "L";
+    readonly L0: "L0";
+    readonly L1: "L1";
+    readonly L1_ID: "L1_ID";
+    readonly L1_IDO: "L1_IDO";
+    readonly L1_NAT: "L1_NAT";
+    readonly L1_IDDOC: "L1_IDDOC";
+    readonly L2: "L2";
+    readonly L_REGDOC: "L_REGDOC";
+    readonly L_TAXDOC: "L_TAXDOC";
+    readonly L_PROOFOFADDRESS: "L_PROOFOFADDRESS";
+    readonly L_PH: "L_PH";
+    readonly L_MOTION: "L_MOTION";
+    readonly L_TAXINFO: "L_TAXINFO";
+    readonly L_BAFIN: "L_BAFIN";
+};
+export type Scenario = (typeof Scenarios)[keyof typeof Scenarios];

package/dist/types/core/models/api/individual.d.ts

@@ -13,6 +13,7 @@ interface NameLocalization {
 export interface Individual {
     birthData?: {
         dateOfBirth: string;
+        placeOfBirth?: string;
     };
     email?: string;
     identificationData?: {

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

@@ -1,4 +1,4 @@
-import type { CountryCodes } from '../../../types/datasets/country-code';
+import type { CountryCode } from '../../../types/datasets/country-code';
 import type { Address } from './address';
 import type { FinancialReport } from './financialReport';
 import type { TaxInformation, VatAbsenceReason } from './organization';
@@ -11,7 +11,7 @@ interface Localization {
 export interface LegalArrangement {
     name: string;
     localization?: Localization[];
-    countryOfGoverningLaw: CountryCodes;
+    countryOfGoverningLaw: CountryCode;
     registeredAddress: Address;
     description?: string;
     doingBusinessAs?: string;

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

@@ -2,10 +2,10 @@ import type { GuidanceQuestionValue } from '../../../components/Individual/forms
 import type { SettlorExemptionReason } from '../../../components/Trust/forms/TrustRoleAndEntityType/types';
 import type { MixpanelProperty } from '../../user-events';
 import type { DecisionMakerType } from './decision-maker-type';
-import type { LegalEntityType } from './legal-entity-type';
+import type { LegalEntityType, LegalEntityTypes } from './legal-entity-type';
 import type { TrustMemberType } from './trust-member-type';
 import type { UnincorporatedPartnershipMemberType } from './unincorporated-partnership';
-export type LegalEntityAssociationType = DecisionMakerType | TrustMemberType | LegalEntityType.TRUST | LegalEntityType.SOLE_PROPRIETORSHIP | LegalEntityType.UNINCORPORATED_PARTNERSHIP | UnincorporatedPartnershipMemberType | 'legalRepresentative' | 'immediateParentCompany' | 'ultimateParentCompany';
+export type LegalEntityAssociationType = DecisionMakerType | TrustMemberType | typeof LegalEntityTypes.TRUST | typeof LegalEntityTypes.SOLE_PROPRIETORSHIP | typeof LegalEntityTypes.UNINCORPORATED_PARTNERSHIP | UnincorporatedPartnershipMemberType | 'legalRepresentative' | 'immediateParentCompany' | 'ultimateParentCompany';
 export type LegalRepresentativeRelationshipType = 'parent' | 'guardian';
 export interface LegalEntityAssociation {
     [key: string]: MixpanelProperty;

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

@@ -1,7 +1,8 @@
-export declare enum LegalEntityType {
-    INDIVIDUAL = "individual",
-    ORGANIZATION = "organization",
-    TRUST = "trust",
-    SOLE_PROPRIETORSHIP = "soleProprietorship",
-    UNINCORPORATED_PARTNERSHIP = "unincorporatedPartnership"
-}
+export type LegalEntityType = (typeof LegalEntityTypes)[keyof typeof LegalEntityTypes];
+export declare const LegalEntityTypes: {
+    readonly INDIVIDUAL: "individual";
+    readonly ORGANIZATION: "organization";
+    readonly TRUST: "trust";
+    readonly SOLE_PROPRIETORSHIP: "soleProprietorship";
+    readonly UNINCORPORATED_PARTNERSHIP: "unincorporatedPartnership";
+};

package/dist/types/core/models/api/trust-member-type.d.ts

@@ -1,8 +1,8 @@
-export declare enum TrustMemberTypes {
-    DEFINED_BENEFICIARY = "definedBeneficiary",
-    UNDEFINED_BENEFICIARY = "undefinedBeneficiary",
-    PROTECTOR = "protector",
-    TRUSTEE = "secondaryTrustee",
-    SETTLOR = "settlor"
-}
-export type TrustMemberType = `${TrustMemberTypes}`;
+export declare const TrustMemberTypes: {
+    readonly DEFINED_BENEFICIARY: "definedBeneficiary";
+    readonly UNDEFINED_BENEFICIARY: "undefinedBeneficiary";
+    readonly PROTECTOR: "protector";
+    readonly TRUSTEE: "secondaryTrustee";
+    readonly SETTLOR: "settlor";
+};
+export type TrustMemberType = (typeof TrustMemberTypes)[keyof typeof TrustMemberTypes];

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

@@ -1,4 +1,5 @@
-export declare enum TrustedFieldsProvider {
-    SINGPASS = "singpass",
-    KOMPANY = "kompany"
-}
+export type TrustedFieldsProvider = (typeof TrustedFieldsProviders)[keyof typeof TrustedFieldsProviders];
+export declare const TrustedFieldsProviders: {
+    readonly SINGPASS: "singpass";
+    readonly KOMPANY: "kompany";
+};

package/dist/types/core/models/api/unincorporated-partnership.d.ts

@@ -2,9 +2,9 @@ import type { LegalArrangement } from './legal-arrangement';
 export type UnincorporatedPartnership = LegalArrangement & {
     type?: 'generalPartnership';
 };
-export declare enum UnincorporatedPartnershipMemberTypes {
-    SECONDARY_PARTNER = "secondaryPartner",
-    OWNER = "uboThroughOwnership",
-    CONTROLLING_PERSON = "uboThroughControl"
-}
-export type UnincorporatedPartnershipMemberType = `${UnincorporatedPartnershipMemberTypes}`;
+export declare const UnincorporatedPartnershipMemberTypes: {
+    readonly SECONDARY_PARTNER: "secondaryPartner";
+    readonly OWNER: "uboThroughOwnership";
+    readonly CONTROLLING_PERSON: "uboThroughControl";
+};
+export type UnincorporatedPartnershipMemberType = (typeof UnincorporatedPartnershipMemberTypes)[keyof typeof UnincorporatedPartnershipMemberTypes];

package/dist/types/core/models/api/verification-error.d.ts

@@ -1,13 +1,14 @@
 import type { ErrorCode } from '../../../types/errors/error-message';
 import type { CapabilityName } from './capability';
 import type { RemediatingAction } from './remediating-action';
-export declare enum VerificationErrorType {
-    DATA_MISSING = "dataMissing",
-    INVALID_INPUT = "invalidInput",
-    PENDING_STATUS = "pendingStatus",
-    DATA_REVIEW = "dataReview",
-    REJECTED = "rejected"
-}
+export type VerificationErrorType = (typeof VerificationErrorTypes)[keyof typeof VerificationErrorTypes];
+export declare const VerificationErrorTypes: {
+    readonly DATA_MISSING: "dataMissing";
+    readonly INVALID_INPUT: "invalidInput";
+    readonly PENDING_STATUS: "pendingStatus";
+    readonly DATA_REVIEW: "dataReview";
+    readonly REJECTED: "rejected";
+};
 export interface VerificationError {
     capabilities?: CapabilityName[];
     code: ErrorCode;

package/dist/types/core/models/api/verification-status.d.ts

@@ -1,6 +1,7 @@
-export declare enum VerificationStatus {
-    VALID = "valid",
-    PENDING = "pending",
-    INVALID = "invalid",
-    REJECTED = "rejected"
-}
+export type VerificationStatus = (typeof VerificationStatuses)[keyof typeof VerificationStatuses];
+export declare const VerificationStatuses: {
+    readonly VALID: "valid";
+    readonly PENDING: "pending";
+    readonly INVALID: "invalid";
+    readonly REJECTED: "rejected";
+};

package/dist/types/core/models/api/view-verification-status.d.ts

@@ -1,10 +1,11 @@
-export declare enum OnboardingStatus {
-    AWAITING_DATA = "AWAITING_DATA",
-    IN_REVIEW = "IN_REVIEW",
-    UNSUCCESSFUL = "UNSUCCESSFUL",
-    REJECTED = "REJECTED",// final state - no status changes further
-    VERIFIED = "VERIFIED"
-}
+export type OnboardingStatus = (typeof OnboardingStatuses)[keyof typeof OnboardingStatuses];
+export declare const OnboardingStatuses: {
+    readonly AWAITING_DATA: "AWAITING_DATA";
+    readonly IN_REVIEW: "IN_REVIEW";
+    readonly UNSUCCESSFUL: "UNSUCCESSFUL";
+    readonly REJECTED: "REJECTED";
+    readonly VERIFIED: "VERIFIED";
+};
 /** @deprecated - rely on contract */
 export interface OnboardingLinkConfig {
     locale: string;

package/dist/types/embeds/business-financing/AdyenBusinessFinancing.d.ts

@@ -6,7 +6,7 @@ import type { AdyenBusinessFinancingProps } from './adyen-business-financing.typ
 type AdyenBusinessFinancingElement = HTMLElement & AdyenBusinessFinancingProps;
 type AdyenBusinessFinancingElementProps = ElementProps<AdyenBusinessFinancingProps>;
 export declare class AdyenBusinessFinancing extends EmbedBaseElement<AdyenBusinessFinancingElementProps> {
-    onSubmitSuccess?(data: BusinessFinancingSchema): void;
+    onComplete?(data: BusinessFinancingSchema): void;
     constructor(props: AdyenBusinessFinancingElementProps);
     render(): AdyenBusinessFinancingElement;
 }

package/dist/types/embeds/business-financing/adyen-business-financing.types.d.ts

@@ -6,7 +6,12 @@ import type { BaseEmbedProps } from '../baseEmbedProps';
  * @see https://docs.adyen.com/platforms/onboard-users/components/transfer-instrument/#initialize-components
  */
 export interface AdyenBusinessFinancingProps extends BaseEmbedProps {
-    onSubmitSuccess?(data: BusinessFinancingSchema): void;
+    /** Invoked when form has been completed by user */
+    onComplete?(data: BusinessFinancingSchema): void;
+    /** Defaults to inline. If modal is selected Component shows as modal */
+    view?: 'modal' | 'inline';
+    /** Invoked only when view='modal', triggers when user clicks the close modal button */
+    onClose?(): void;
 }
 declare module 'preact/jsx-runtime' {
     namespace JSX {

package/dist/types/embeds/individual/adyen-individual.types.d.ts

@@ -1,9 +1,14 @@
 import type { DOMAttributes } from 'react';
 import type { DefineComponent } from 'vue';
+import type { IndividualSchema } from '../../components/Individual/forms/Individual/types';
 import type { BaseEmbedProps } from '../baseEmbedProps';
 export interface AdyenIndividualProps extends BaseEmbedProps {
-    /** View, can be `inline` or `modal`. Defaults to `inline` */
+    /** Invoked when form has been completed by user */
+    onComplete?(data: IndividualSchema): void;
+    /** Defaults to inline. If modal is selected Component shows as modal */
     view?: 'modal' | 'inline';
+    /** Invoked only when view='modal', triggers when user clicks the close modal button */
+    onClose?(): void;
 }
 declare module 'preact/jsx-runtime' {
     namespace JSX {

package/dist/types/embeds/onboarding/AdyenOnboarding.d.ts

@@ -5,6 +5,7 @@ import type { AdyenOnboardingProps } from './adyen-onboarding.types';
 type AdyenOnboardingElement = HTMLElement & AdyenOnboardingProps;
 type AdyenOnboardingElementProps = ElementProps<AdyenOnboardingProps>;
 export declare class AdyenOnboarding extends EmbedBaseElement<AdyenOnboardingElementProps> {
+    openbankingpartnerconfigid?: string;
     constructor(props: AdyenOnboardingElementProps);
     render(): AdyenOnboardingElement;
 }

package/dist/types/embeds/onboarding/adyen-onboarding.types.d.ts

@@ -1,7 +1,10 @@
 import type { DOMAttributes } from 'react';
 import type { DefineComponent } from 'vue';
 import type { BaseEmbedProps } from '../baseEmbedProps';
-export type AdyenOnboardingProps = BaseEmbedProps;
+export interface AdyenOnboardingProps extends BaseEmbedProps {
+    /** ConfigId setup to use open banking integration with Plaid **/
+    openbankingpartnerconfigid?: string;
+}
 declare module 'preact/jsx-runtime' {
     namespace JSX {
         interface IntrinsicElements {

package/dist/types/embeds/terms-of-service/adyen-terms-of-service.types.d.ts

@@ -1,9 +1,15 @@
 import type { DOMAttributes } from 'react';
 import type { DefineComponent } from 'vue';
+import type { OnAcceptPayload } from '../../components/EmbeddedDropins/AcceptTermsOfServiceComponent/AcceptTermsOfServiceComponent';
 import type { BaseEmbedProps } from '../baseEmbedProps';
 export interface AdyenTermsOfServiceProps extends BaseEmbedProps {
-    /** View, can be inline or modal. Defaults to inline */
+    /** Invoked every time a contract is accepted. Typically there are more then one documents to accept. */
+    onAccept?(data: OnAcceptPayload): void;
+    /** Invoked when form has been completed by user */
+    /** Defaults to inline. If modal is selected Component shows as modal */
     view?: 'modal' | 'inline';
+    /** Invoked only when view='modal', triggers when user clicks the close modal button */
+    onClose?(): void;
 }
 declare module 'preact/jsx-runtime' {
     namespace JSX {

package/dist/types/embeds/transfer-instrument/AdyenTransferInstrument.d.ts

@@ -8,7 +8,8 @@ type AdyenTransferInstrumentElementProps = ElementProps<AdyenTransferInstrumentP
 export declare class AdyenTransferInstrument extends EmbedBaseElement<AdyenTransferInstrumentElementProps> {
     view: 'modal' | 'inline';
     transferInstrumentId?: string;
-    onSubmitSuccess?(d: PayoutDetailsSchema): void;
+    onComplete?(d: PayoutDetailsSchema): void;
+    openbankingpartnerconfigid?: string;
     constructor(props: AdyenTransferInstrumentElementProps);
     render(): AdyenTransferInstrumentElement;
 }

package/dist/types/embeds/transfer-instrument/adyen-transfer-instrument.types.d.ts

@@ -7,9 +7,14 @@ import type { BaseEmbedProps } from '../baseEmbedProps';
  */
 export interface AdyenTransferInstrumentProps extends BaseEmbedProps {
     transferinstrumentid?: string;
-    /** View, can be inline or modal. Defaults to inline */
+    /** ConfigId setup to use open banking integration with Plaid **/
+    openbankingpartnerconfigid?: string;
+    /** Invoked when form has been completed by user */
+    onComplete?(data: PayoutDetailsSchema): void;
+    /** Defaults to inline. If modal is selected Component shows as modal */
     view?: 'modal' | 'inline';
-    onSubmitSuccess?(d: PayoutDetailsSchema): void;
+    /** Invoked only when view='modal', triggers when user clicks the close modal button */
+    onClose?(): void;
 }
 declare module 'preact/jsx-runtime' {
     namespace JSX {

package/dist/types/hooks/introduction/useIntroductionScreens.d.ts

@@ -1,8 +1,8 @@
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
-import { IntroductionScreens } from '../../components/Shared/Introduction/types';
-import { TaskTypes } from '../../stores/globalStore/taskTypes';
+import { type IntroductionScreen } from '../../components/Shared/Introduction/types';
+import { type TaskType } from '../../stores/globalStore/taskTypes';
 export interface UseIntroductionScreensProps {
     legalEntity: ExistingLegalEntity;
-    tasks: TaskTypes[];
+    tasks: TaskType[];
 }
-export declare const useIntroductionScreens: ({ legalEntity, tasks }: UseIntroductionScreensProps) => IntroductionScreens[] | undefined;
+export declare const useIntroductionScreens: ({ legalEntity, tasks }: UseIntroductionScreensProps) => IntroductionScreen[] | undefined;

package/dist/types/hooks/singpass/useSingpassMyInfoLogin.d.ts

@@ -2,12 +2,13 @@ import type { Translatable } from '../../../types';
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
 import type { UniqueEntityAssociation } from '../../components/Shared/EntityAssociation/types';
 import type { AccountHolderOption } from '../../types/accountHolder';
-declare enum SingpassMyInfoLoginActionType {
-    LOADING = "LOADING",
-    SUCCESS = "SUCCESS",
-    FAILURE = "FAILURE",
-    RESET = "RESET"
-}
+export type SingpassMyInfoLoginActionType = (typeof SingpassMyInfoLoginActionTypes)[keyof typeof SingpassMyInfoLoginActionTypes];
+declare const SingpassMyInfoLoginActionTypes: {
+    readonly LOADING: "LOADING";
+    readonly SUCCESS: "SUCCESS";
+    readonly FAILURE: "FAILURE";
+    readonly RESET: "RESET";
+};
 interface SingpassMyInfoLoginAction {
     type: SingpassMyInfoLoginActionType;
     isLoading: boolean;

package/dist/types/hooks/useBusinessSetup.d.ts

@@ -1,13 +1,14 @@
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
 import type { AccountHolderOption } from '../types/accountHolder';
-export declare enum BusinessType {
-    INDIVIDUAL = "individual",
-    COMPANY = "company",
-    INCORPORATED_PARTNERSHIP = "partnershipIncorporated",
-    UNINCORPORATED_PARTNERSHIP = "partnershipUnincorporated",
-    INDIVIDUAL_TRUSTEE = "individualTrustee",
-    COMPANY_TRUSTEE = "companyTrustee",
-    SOLE_PROPRIETORSHIP = "soleProprietorship",
-    INCORPORATE_ASSOCIATION = "associationIncorporated"
-}
+export type BusinessType = (typeof BusinessTypes)[keyof typeof BusinessTypes];
+export declare const BusinessTypes: {
+    readonly INDIVIDUAL: "individual";
+    readonly COMPANY: "company";
+    readonly INCORPORATED_PARTNERSHIP: "partnershipIncorporated";
+    readonly UNINCORPORATED_PARTNERSHIP: "partnershipUnincorporated";
+    readonly INDIVIDUAL_TRUSTEE: "individualTrustee";
+    readonly COMPANY_TRUSTEE: "companyTrustee";
+    readonly SOLE_PROPRIETORSHIP: "soleProprietorship";
+    readonly INCORPORATE_ASSOCIATION: "associationIncorporated";
+};
 export declare const useBusinessSetup: (legalEntityResponse: ExistingLegalEntity) => BusinessType | AccountHolderOption | undefined;

package/dist/types/hooks/useDataMissingRemediations.d.ts

@@ -1,11 +1,11 @@
-import { TaskTypes } from '../stores/globalStore/taskTypes';
+import { type TaskType } from '../stores/globalStore/taskTypes';
 import type { CapabilityProblems } from '../types/errors/capability-problems';
 interface UseDataMissingRemediationsProps {
     legalEntityId: string;
     problems: CapabilityProblems;
 }
 interface DataMissingRemediations {
-    remediationMessages: Partial<Record<TaskTypes, string | undefined>>;
+    remediationMessages: Partial<Record<TaskType, string | undefined>>;
 }
 /**
  * @description A hook that parses a legal entities capability problems and maps its verification error codes to task specific remediation messages

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

@@ -5,7 +5,7 @@ import type { EntityProblems } from '../types/errors/entity-problems';
 import type { FormModelWithValidity } from '../types/form';
 import type { Form } from './useMultiForm/types';
 export interface FormComposer {
-    handleNextClick(): void;
+    handleNextClick(updatedForms?: FormModelWithValidity[]): void;
     handleBackClick?(): void;
     gotoFormByFormIndex(index: number): void;
     activeForm: FormModelWithValidity;

package/dist/types/hooks/useLegalCompanyNameField/useLegalCompanyNameField.d.ts

@@ -1,9 +1,12 @@
 import type { JSX } from 'preact';
-import type { Form } from '../useForm/types';
+import type { NestedErrorState, NestedValidState } from '../useMultiForm/types';
 import type { CountryCode } from '../../types/datasets/country-code';
 import type { FormUtils } from '../../utils/formUtils';
-interface UseLegalCompanyNameFieldProps<FormSchema> extends Omit<Form<FormSchema>, 'setFieldProblems' | 'setData' | 'setErrors' | 'setValid' | 'triggerValidation' | 'mergeForm' | 'resetToDefaultData' | 'schema'> {
+interface UseLegalCompanyNameFieldProps<FormSchema> {
     data: FormSchema;
+    valid: NestedValidState<FormSchema>;
+    errors: NestedErrorState<FormSchema>;
+    fieldProblems: NestedValidState<FormSchema>;
     country: CountryCode;
     formUtils: FormUtils<FormSchema>;
     fieldOptions: {
@@ -19,7 +22,7 @@ export declare function useLegalCompanyNameField<FormSchema>({ data, valid, erro
     readonly: boolean;
     onInput: (e: any) => void;
     onBlur: (e: FocusEvent) => void;
-    isValid: Record<keyof FormSchema, boolean>[keyof FormSchema];
+    isValid: NestedValidState<FormSchema>[keyof FormSchema];
     errorMessage: Record<keyof FormSchema, boolean | import("../../../types").Translatable>[keyof FormSchema];
     label: Partial<Record<keyof FormSchema, string>>[keyof FormSchema];
     helper: Partial<Record<keyof FormSchema, string>>[keyof FormSchema];

package/dist/types/hooks/useLegalEntityType.d.ts

@@ -1,5 +1,5 @@
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
-import { LegalEntityType } from '../core/models/api/legal-entity-type';
+import { type LegalEntityType } from '../core/models/api/legal-entity-type';
 export interface UseLegalEntityTypeProps {
     legalEntity: ExistingLegalEntity;
 }

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

@@ -20,51 +20,50 @@ export interface FormState<InnerFormSchema> {
     dataStoreId?: string;
     local?: FormState<InnerFormSchema> | Partial<FormState<InnerFormSchema>>;
 }
+export type FormName<T> = keyof {
+    [InnerFormName in keyof T]: T[InnerFormName];
+};
+export type NestedSchema<T> = T[keyof T];
 export interface Form<T> extends MultiFormState<T> {
-    setData: (key: keyof NestedSchema<T>, value: FieldValue<NestedSchema<T>>, formName: FormName<T>) => void;
+    setData<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: FieldValue<NestedSchema<T>>, formName: InnerFormName): void;
     setFormData: <FN extends FormName<T>>(formName: FN, formData: T[FN]) => void;
-    setValid: (key: keyof NestedSchema<T>, value: boolean, formName: FormName<T>) => void;
-    setErrors: (key: keyof NestedSchema<T>, value: ValidationRuleResult | null, formName: FormName<T>) => void;
+    setValid<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: boolean, formName: InnerFormName): void;
+    setErrors<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: ValidationRuleResult | null, formName: InnerFormName): void;
     handleChangeFor<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], formName: InnerFormName, mode?: ValidatorMode): (e: any) => void;
-    triggerValidation: (formName: FormName<T>, selectedSchema?: (keyof NestedSchema<T>)[]) => Promise<boolean>;
+    triggerValidation<InnerFormName extends keyof T>(formName: InnerFormName, selectedSchema?: Array<keyof Required<T>[InnerFormName]>): Promise<boolean>;
     resetToDefaultData: () => void;
     defaultData?: T;
 }
-export type FormName<T> = keyof {
-    [InnerFormName in keyof T]: T[InnerFormName];
+export type NestedErrorState<InnerFormSchema> = {
+    [FieldName in keyof InnerFormSchema]: ValidationRuleResult | null;
+};
+export type NestedValidState<InnerFormSchema> = {
+    [FieldName in keyof InnerFormSchema]: boolean;
+};
+export type MultiFormErrorState<TopLevelSchema> = {
+    [InnerFormName in keyof TopLevelSchema]: NestedErrorState<TopLevelSchema[InnerFormName]>;
+};
+export type MultiFormValidState<TopLevelSchema> = {
+    [InnerFormName in keyof TopLevelSchema]: NestedValidState<TopLevelSchema[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;
-        };
+    errors: MultiFormErrorState<T>;
+    asyncErrors: MultiFormErrorState<T>;
+    valid: MultiFormValidState<T>;
+    fieldProblems: MultiFormValidState<T>;
+    allFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
-    obscuredFields?: {
+    requiredFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
     optionalFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
     trustedFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
@@ -77,11 +76,6 @@ export type MultiFormState<T> = {
     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]>;
@@ -101,12 +95,20 @@ export interface MultiFormOptions<T> {
             [FieldName in keyof T[InnerFormName]]: boolean;
         };
     };
-    obscuredFields?: {
+    allFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
+    requiredFields?: {
+        [InnerFormName in keyof T]: (keyof Required<T[InnerFormName]>)[];
+    } | ((data: T | undefined) => {
+        [InnerFormName in keyof T]: (keyof T[InnerFormName])[];
+    });
     optionalFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
     trustedFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };

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

@@ -1,2 +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>;
+export declare function useMultiForm<FormSchema>({ defaultData, rules, asyncRules, fieldProblems, allFields, requiredFields, obscuredFields, optionalFields, trustedFields, formatters, }: MultiFormOptions<FormSchema>): Form<FormSchema>;

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

@@ -5,13 +5,13 @@ import type { LoadingStatus } from '../components/ui/atoms/LoaderWrapper/constan
 import type { TopLevelDataSchema } from '../context/StateContext/types';
 import type { AccountFormatRequirements, PayoutAccountFormats } from '../datasets/generators/getAccountFormatForCountry';
 import type { LegalEntityType } from '../core/models/api/legal-entity-type';
-import type { TaskTypes } from '../stores/globalStore/taskTypes';
+import type { TaskType } from '../stores/globalStore/taskTypes';
 import type { CountryCode } from '../types/datasets/country-code';
 import type { FormConfiguration } from '../types/form-configuration';
 import type { BankAccountFormatType } from '../components/BankAccount/fields/BankAccountFormat/types';
 export type ParseConfiguration<TLDS extends TopLevelDataSchema> = (configuration: {
     scenarios: Scenario[];
-    taskList?: TaskTypes[];
+    taskList?: TaskType[];
     provider?: BankVerificationVendor;
     bankVerificationProviders?: Partial<Record<CountryCode, string>>;
     requiredFields: AccountFormatRequirements | undefined;

package/dist/types/language/Language.d.ts

@@ -12,6 +12,7 @@ export declare class Language {
     /**
      * Returns a translated string from a key in the current {@link Language.locale}
      * @returns Translated string in the user's locale
+     * @deprecated we now have i18next for i18n, check out {@link /src/language/README.md} for more details and examples
      */
     get(translatable: Translatable, translationOptions?: GetTranslationOptions): string;
 }

package/dist/types/language/utils.d.ts

@@ -1,5 +1,6 @@
+import type { TFunction } from 'i18next';
 import type { CountryCode } from '../types/datasets/country-code';
-import type { TranslationItem, TranslationKey, Translations } from './types';
+import type { Translatable, TranslationItem, TranslationKey, Translations } from './types';
 /**
  * Matches a string with one of the locales
 
@@ -39,3 +40,12 @@ export declare const getTranslationByKey: (translations: Translations, key: Tran
  * // returns 'en'
  */
 export declare const getLanguageCode: (locale: string) => string;
+/**
+ * A helper function to translate a `Translatable` type, which can be either a simple string key
+ * or an object with a key and values for interpolation. It uses the provided `i18next` `t` function.
+ *
+ * @param t - The `i18next` translation function.
+ * @param translatable - The string or object to translate.
+ * @returns The translated string.
+ */
+export declare const translateStringOrObject: (t: TFunction, translatable: Translatable) => string;