@adyen/kyc-components 4.0.0-beta.0 → 4.0.0-beta.3

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

@@ -0,0 +1,16 @@
+import './adyen-transfer-instrument';
+import type { PayoutDetailsSchema } from '../../components/BankAccount/forms/PayoutDetails/types';
+import type { ElementProps } from '../baseEmbedProps';
+import { EmbedBaseElement } from '../EmbedBaseElement';
+import type { AdyenTransferInstrumentProps } from './adyen-transfer-instrument.types';
+type AdyenTransferInstrumentElement = HTMLElement & AdyenTransferInstrumentProps;
+type AdyenTransferInstrumentElementProps = ElementProps<AdyenTransferInstrumentProps>;
+export declare class AdyenTransferInstrument extends EmbedBaseElement<AdyenTransferInstrumentElementProps> {
+    view: 'modal' | 'inline';
+    transferInstrumentId?: string;
+    onComplete?(d: PayoutDetailsSchema): void;
+    openbankingpartnerconfigid?: string;
+    constructor(props: AdyenTransferInstrumentElementProps);
+    render(): AdyenTransferInstrumentElement;
+}
+export {};

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/embeds/verification-status/AdyenVerificationStatus.d.ts

@@ -0,0 +1,20 @@
+import './adyen-verification-status';
+import type { OnboardingStatus } from '../../core/models/api/view-verification-status';
+import type { ErrorEntity, OnboardingRedirectConfig } from '../../components/EmbeddedDropins/ViewVerificationStatus/types';
+import type { ElementProps } from '../baseEmbedProps';
+import { EmbedBaseElement } from '../EmbedBaseElement';
+import type { AdyenVerificationStatusProps } from './adyen-verification-status.types';
+type AdyenVerificationStatusElement = HTMLElement & AdyenVerificationStatusProps;
+type AdyenVerificationStatusElementProps = ElementProps<AdyenVerificationStatusProps>;
+export declare class AdyenVerificationStatus extends EmbedBaseElement<AdyenVerificationStatusElementProps> {
+    hideexplanation?: boolean;
+    returnurl?: string;
+    redirecttarget?: '_blank' | '_self';
+    themeid?: string;
+    onStatusChange?: (status: OnboardingStatus) => void;
+    onError?: (errorEntity: ErrorEntity) => void;
+    onRedirect?: (config: OnboardingRedirectConfig) => void;
+    constructor(props: AdyenVerificationStatusElementProps);
+    render(): AdyenVerificationStatusElement;
+}
+export {};

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

@@ -5,4 +5,4 @@ export interface UseIntroductionScreensProps {
     legalEntity: ExistingLegalEntity;
     tasks: TaskTypes[];
 }
-export declare const useIntroductionScreens: ({ legalEntity, tasks }: UseIntroductionScreensProps) => IntroductionScreens[];
+export declare const useIntroductionScreens: ({ legalEntity, tasks }: UseIntroductionScreensProps) => IntroductionScreens[] | undefined;

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

@@ -1,7 +1,8 @@
-export interface UseHasSeenSingpassSelectionProps {
+interface UseHasSeenSingpassSelectionProps {
     legalEntityId: string;
 }
 export declare const useHasSeenSingpassSelection: ({ legalEntityId, }: UseHasSeenSingpassSelectionProps) => {
     hasSeenSingpassSelection: boolean;
     setHasSeenSingpassSelection: import("preact/hooks").Dispatch<import("preact/hooks").StateUpdater<boolean>>;
 };
+export {};

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

@@ -1,7 +1,7 @@
-import type { AccountHolderOption } from '../../core/types/AccountHolder.types';
 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",
@@ -23,7 +23,7 @@ export declare const getTrustedEntityAssociations: (legalEntityTrustedFields: st
 export declare const useSingpassMyInfoLogin: ({ legalEntity, accountHolder, }: UseSingpassMyInfoLoginProps) => {
     isEligibleForSingpass: boolean;
     state: SingpassMyInfoLoginState;
-    handleInitiateSingpassMyInfoLogin: () => Promise<string>;
+    handleInitiateSingpassMyInfoLogin: () => Promise<string | undefined>;
     handleSingpassMyInfoLoginSuccess: () => void;
     handleSingpassMyInfoLoginFailure: (errorMessage: Translatable) => void;
     handleSingpassMyInfoLoginReset: () => void;

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

@@ -1,4 +1,4 @@
-import type { AccountHolderOption } from '../core/types/AccountHolder.types';
+import type { AccountHolderOption } from '../types/accountHolder';
 interface UseAccountHolder {
     accountHolder: AccountHolderOption | undefined;
     setAccountHolder: (accountHolder: AccountHolderOption | undefined) => void;

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

@@ -1,2 +1,2 @@
-import type { CountryCode } from '../core/models/country-code';
+import type { CountryCode } from '../types/datasets/country-code';
 export declare const useAllowedCountries: () => CountryCode[] | undefined;

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

@@ -3,9 +3,10 @@ import { ValidationResult } from '../utils/validation/validationResult';
 import type { FormState } from './useForm/types';
 export type AsyncValidationResults<FormSchema> = Partial<Record<keyof FormSchema, ValidationResult>>;
 export type TriggerAsyncValidation<FormSchema> = (field: keyof FormSchema, formState: FormState<FormSchema>, mode: ValidatorMode) => void;
-export type UseAsyncValidator<FormSchema> = {
+type UseAsyncValidator<FormSchema> = {
     asyncValidationResults: AsyncValidationResults<FormSchema>;
     triggerAsyncValidation: TriggerAsyncValidation<FormSchema>;
     clearAsyncValidationResults: (field: keyof FormSchema) => void;
 };
 export declare const useAsyncValidator: <FormSchema>(asyncRules?: AsyncValidatorRules<FormSchema>) => UseAsyncValidator<FormSchema>;
+export {};

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

@@ -1,5 +1,5 @@
-import type { AccountHolderOption } from '../core/types/AccountHolder.types';
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
+import type { AccountHolderOption } from '../types/accountHolder';
 export declare enum BusinessType {
     INDIVIDUAL = "individual",
     COMPANY = "company",

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

@@ -1,6 +1,5 @@
 import type { Address } from '../core/models/api/address';
 import type { DatasetUtil } from '../utils/datasetUtil';
-import type { IndividualOnfidoConflictsSchema } from '../components/Individual/forms/IndividualOnfido/IdVerificationMethod/individualOnfidoConflictsSchema';
 export type RuleResult<T> = {
     hasConflict: boolean;
     resolvedValue?: T;
@@ -12,11 +11,6 @@ export declare const defaultConflictRule: <T>(provided?: T, detected?: T) => Rul
  * The rule handles enrichment (auto-resolution) and deep equality checks.
  */
 export declare const createAddressConflictRule: (datasetUtils: DatasetUtil) => ConflictRule<Address | undefined>;
-/**
- * A factory function that returns a conflict rule for the `id` object.
- * Currently, it is configured to always ignore conflicts.
- */
-export declare const createIdConflictRule: () => ConflictRule<IndividualOnfidoConflictsSchema["id"]>;
 type UseDataConflictsReturn<T extends object> = {
     hasConflicts: boolean;
     conflictingProperties: (keyof T)[];

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

@@ -1,5 +1,5 @@
-import type { CapabilityProblems } from '../core/models/errors/capability-problems';
 import { TaskTypes } from '../stores/globalStore/taskTypes';
+import type { CapabilityProblems } from '../types/errors/capability-problems';
 interface UseDataMissingRemediationsProps {
     legalEntityId: string;
     problems: CapabilityProblems;

package/dist/types/hooks/useForm/reducer.d.ts

@@ -18,8 +18,8 @@ export interface InitOptions<FormSchema> {
  * Processes default data and sets initial state
  */
 export declare function init<FormSchema>({ schema, defaultData, fieldProblems, obscuredFields, optionalFields, trustedFields, formatters, staticValidate, asyncValidate, }: InitOptions<FormSchema>): FormState<FormSchema>;
-export type ReducerActionType = 'setData' | 'setValid' | 'setErrors' | 'setFieldProblems' | 'updateField' | 'mergeForm' | 'setSchema' | 'validateForm';
-export interface ReducerAction<FormSchema> {
+type ReducerActionType = 'setData' | 'setValid' | 'setErrors' | 'setFieldProblems' | 'updateField' | 'mergeForm' | 'setSchema' | 'validateForm';
+interface ReducerAction<FormSchema> {
     type: ReducerActionType;
     key?: keyof FormSchema;
     mode?: ValidatorMode;

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

@@ -1,12 +1,11 @@
 import type { Dispatch, StateUpdater } from 'preact/hooks';
-import type { AnyFormIdOfTLDS } from '../../context/StateContext/types';
 import type { Translatable, TranslationKey } from '../../../types';
 import type { CapabilityName } from '../../core/models/api/capability';
 import type { TrustedFieldsProvider } from '../../core/models/api/trusted-fields-provider';
-import type { CountryCode } from '../../core/models/country-code';
-import type { EntityProblems } from '../../core/models/errors/entity-problems';
-import type { FormVerificationErrors } from '../../core/models/errors/form-verification-errors';
-import type { FormModel } from '../../core/models/form';
+import type { CountryCode } from '../../types/datasets/country-code';
+import type { EntityProblems } from '../../types/errors/entity-problems';
+import type { FormVerificationErrors } from '../../types/errors/form-verification-errors';
+import type { FormModel } from '../../types/form';
 import type { Mask } from '../../utils/masking/maskTypes';
 import type { ValidationRuleResult, ValidatorMode, ValidatorRules } from '../../utils/validation/types';
 export type FieldData<FieldSchema> = {
@@ -15,10 +14,10 @@ export type FieldData<FieldSchema> = {
 export type FieldValid<FieldSchema> = {
     [fieldValid in keyof FieldSchema]: boolean;
 };
-export type FieldErrors<FieldSchema> = {
+type FieldErrors<FieldSchema> = {
     [fieldError in keyof FieldSchema]: Translatable | boolean;
 };
-export type FieldLabels<FieldSchema> = {
+type FieldLabels<FieldSchema> = {
     [fieldLabel in keyof FieldSchema]?: string;
 };
 export interface MaskSettings {
@@ -38,8 +37,6 @@ export interface BaseFormFieldProps<FieldSchema> {
     guidanceText?: Partial<Record<keyof FieldSchema, string>>;
     placeholders?: Partial<Record<keyof FieldSchema, string>>;
     className?: string;
-    classNameModifiers?: string[];
-    stateSliceId?: AnyFormIdOfTLDS;
     name?: string;
     requiredFields?: Partial<Array<keyof FieldSchema>>;
     handleChangeFor: (key: keyof FieldSchema, mode?: ValidatorMode) => (e: any) => void;
@@ -107,33 +104,31 @@ export interface BaseFormProps<FormSchema> {
     trustedFieldsProvider?: TrustedFieldsProvider;
     onChange?(state: FormState<FormSchema>): void;
 }
-export interface BaseOuterFormProps<FormSchema> extends BaseFormProps<FormSchema> {
+export interface BaseOuterFormProps<OuterFormSchema> extends BaseFormProps<OuterFormSchema> {
     problems?: EntityProblems;
     country?: CountryCode;
     activeForm?: FormModel;
     allFields?: {
-        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+        [InnerFormName in keyof OuterFormSchema]: Array<keyof OuterFormSchema[InnerFormName]>;
     };
     requiredFields?: {
-        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+        [InnerFormName in keyof OuterFormSchema]: Array<keyof OuterFormSchema[InnerFormName]>;
     };
     optionalFields?: {
-        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+        [InnerFormName in keyof OuterFormSchema]: Array<keyof OuterFormSchema[InnerFormName]>;
     };
     verifyFields?: {
-        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+        [InnerFormName in keyof OuterFormSchema]: Array<keyof OuterFormSchema[InnerFormName]>;
     };
     readOnlyFields?: {
-        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+        [InnerFormName in keyof OuterFormSchema]: Array<keyof OuterFormSchema[InnerFormName]>;
     };
     obscuredFields?: {
-        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+        [InnerFormName in keyof OuterFormSchema]: Array<keyof OuterFormSchema[InnerFormName]>;
     };
     trustedFields?: {
-        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+        [InnerFormName in keyof OuterFormSchema]: Array<keyof OuterFormSchema[InnerFormName]>;
     };
-    evaluateConfiguration?: (data: FormSchema) => void;
-    setCustomFormNavigationHandlers?(formId: string, onNext: () => void, onBack: () => void): void;
     setHideSidebar?: Dispatch<StateUpdater<boolean>>;
     setHideFooter?: Dispatch<StateUpdater<boolean>>;
     setSkipSubmit?: Dispatch<StateUpdater<boolean>>;

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

@@ -1,8 +1,8 @@
 import type { Dispatch, StateUpdater } from 'preact/hooks';
 import type { TopLevelDataSchema } from '../context/StateContext/types';
 import type { AdditionalEventProperties } from '../core/user-events';
-import type { EntityProblems } from '../core/models/errors/entity-problems';
-import type { FormModelWithValidity } from '../core/models/form';
+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;

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

@@ -0,0 +1,28 @@
+import type { JSX } from 'preact';
+import type { Form } from '../useForm/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'> {
+    data: FormSchema;
+    country: CountryCode;
+    formUtils: FormUtils<FormSchema>;
+    fieldOptions: {
+        [key in keyof FormSchema]: {
+            onInput: (e: any) => void;
+            onBlur: (e: FocusEvent) => void;
+        };
+    };
+}
+export declare function useLegalCompanyNameField<FormSchema>({ data, valid, errors, fieldProblems, country, formUtils, fieldOptions, }: UseLegalCompanyNameFieldProps<FormSchema>): ({
+    name: string;
+    value: string;
+    readonly: boolean;
+    onInput: (e: any) => void;
+    onBlur: (e: FocusEvent) => void;
+    isValid: Record<keyof FormSchema, boolean>[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];
+    onKeyDown: (e: JSX.TargetedKeyboardEvent<HTMLInputElement>) => void;
+} | undefined)[];
+export {};

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

@@ -50,8 +50,8 @@ export interface MultiFormInitOptions<T> {
  * @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' | 'setFormData' | 'setValid' | 'setErrors' | 'updateField' | 'setInnerFormRequiredFields' | 'setRequiredFields' | 'validateForm' | 'setAsyncErrors';
-export interface ReducerAction<FormSchema> {
+type ReducerActionType = 'setData' | 'setFormData' | 'setValid' | 'setErrors' | 'updateField' | 'setInnerFormRequiredFields' | 'setRequiredFields' | 'validateForm' | 'setAsyncErrors';
+interface ReducerAction<FormSchema> {
     type: ReducerActionType;
     key?: keyof NestedSchema<FormSchema>;
     mode?: ValidatorMode;
@@ -70,7 +70,7 @@ export interface ReducerAction<FormSchema> {
     formValue?: FormState<NestedSchema<FormSchema>>;
     asyncValidationResults?: Record<keyof NestedSchema<FormSchema>, ValidationResult>;
 }
-export interface GetReducerOptions<T> {
+interface GetReducerOptions<T> {
     staticValidate: TriggerStaticValidation<T>;
     obscuredFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
@@ -88,3 +88,4 @@ export interface GetReducerOptions<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>;
+export {};

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

@@ -1,23 +1,10 @@
-import type { Translatable, TranslationKey } from '../../../types';
-import type { TrustedFieldsProvider } from '../../core/models/api/trusted-fields-provider';
-import type { Mask } from '../../utils/masking/maskTypes';
 import type { AsyncValidatorRules, FormatRules, ValidationRuleResult, ValidatorMode, ValidatorRules } from '../../utils/validation/types';
 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>;
@@ -33,70 +20,43 @@ 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 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 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;
-        };
+    errors: MultiFormErrorState<T>;
+    asyncErrors: MultiFormErrorState<T>;
+    valid: MultiFormValidState<T>;
+    fieldProblems: MultiFormValidState<T>;
+    allFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
-    fieldProblems: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: boolean;
-        };
+    requiredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
     obscuredFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
@@ -116,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]>;
@@ -140,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/useMultiForm/useMultiFormAsyncValidator.d.ts

@@ -1,8 +1,7 @@
 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> = {
+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;
     }>;
@@ -14,3 +13,4 @@ export type UseAsyncValidator<FormSchema> = {
  * @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>;
+export {};

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

@@ -1,13 +1,13 @@
 import type { Dispatch, StateUpdater } from 'preact/hooks';
-import type { Scenario } from '../api/configurations/useScenarios';
-import type { BankVerificationVendor } from '../api/transferInstruments/useBankVerificationProviders';
+import type { Scenario } from '../api/configurations/configurations.types';
+import type { BankVerificationVendor } from '../api/transferInstruments/transferInstruments.types';
 import type { LoadingStatus } from '../components/ui/atoms/LoaderWrapper/constants';
 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 { CountryCode } from '../core/models/country-code';
-import type { FormConfiguration } from '../core/models/form-configuration';
 import type { TaskTypes } 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[];
@@ -18,7 +18,7 @@ export type ParseConfiguration<TLDS extends TopLevelDataSchema> = (configuration
     bankVerificationAvailable?: boolean;
     country: CountryCode;
 }) => FormConfiguration<TLDS, string>;
-export interface UseScenarioConfigurationOptions<TLDS extends TopLevelDataSchema> {
+interface UseScenarioConfigurationOptions<TLDS extends TopLevelDataSchema> {
     parseConfiguration: ParseConfiguration<TLDS>;
     country: CountryCode;
     legalEntityType: LegalEntityType;

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

@@ -3,7 +3,6 @@ import type { GetTranslationOptions } from './utils';
 export declare class Language {
     private readonly supportedLocales;
     readonly translations: Translations;
-    readonly languageCode: string;
     readonly locale: string;
     constructor({ locale, translations, allowedLocales, }: {
         locale?: string;
@@ -13,12 +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;
-    /**
-     * Returns a localized string for a date
-     * @param date - Date to be localized
-     * @param options - Options for {@link Intl.DateTimeFormatOptions}
-     */
-    date(date: string, options?: Intl.DateTimeFormatOptions): string;
 }

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

@@ -0,0 +1,2 @@
+import i18n from 'i18next';
+export default i18n;

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

@@ -1,3 +1,4 @@
+import type introductionKeys from '#shared/language/introduction/en-US.json';
 import type translations from './locales/en-US.json';
 export type TranslationKey = keyof typeof translations;
 export type TranslationItem = string;
@@ -7,3 +8,5 @@ export type TranslationObject = {
     values: Record<string, string>;
 };
 export type Translatable = TranslationKey | TranslationObject;
+export type CommonKey = keyof typeof translations;
+export type IntroductionKey = keyof typeof introductionKeys;

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

@@ -1,5 +1,6 @@
-import type { CountryCode } from '../core/models/country-code';
-import type { TranslationItem, TranslationKey, Translations } from './types';
+import type { TFunction } from 'i18next';
+import type { CountryCode } from '../types/datasets/country-code';
+import type { Translatable, TranslationItem, TranslationKey, Translations } from './types';
 /**
  * Matches a string with one of the locales
 
@@ -31,7 +32,6 @@ export interface GetTranslationOptions {
  * Returns a translation string by key
  */
 export declare const getTranslationByKey: (translations: Translations, key: TranslationKey, options?: GetTranslationOptions) => TranslationItem | null;
-export declare const getTranslationKeysByPrefix: (translations: Translations, keyPrefix: string) => TranslationKey[];
 /**
  * Returns a LanguageCode from locale
  * @param locale - The locale the user wants to use
@@ -40,3 +40,12 @@ export declare const getTranslationKeysByPrefix: (translations: Translations, ke
  * // 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;

package/dist/types/stores/globalStore/calculateTaskStatus.d.ts

@@ -1,8 +1,8 @@
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
 import type { LegalEntityAssociation } from '../../core/models/api/legal-entity-association';
-import type { CapabilityProblems } from '../../core/models/errors/capability-problems';
-import type { AccountHolderOption } from '../../core/types/AccountHolder.types';
 import type { TransferInstrumentOverview } from '../../core/models/api/transfer-instrument';
+import type { AccountHolderOption } from '../../types/accountHolder';
+import type { CapabilityProblems } from '../../types/errors/capability-problems';
 import type { TrustMember } from '../../components/Trust/tasks/TrustMembers/types';
 import type { TaskIdentifier } from './globalStore';
 import type { TaskStatusWithReason } from './taskStatus';