@adyen/kyc-components 1.6.2 → 2.1.0

package/dist/types/core/Context/CoreProvider.d.ts

@@ -1,46 +1,35 @@
 import { Component } from 'preact';
-export interface CommonPropsTypes {
-    showInlineErrors?: boolean;
-}
+import { PropsWithChildren } from 'preact/compat';
+import { AccountHolderOption } from '../../components/internal/AccountHolder/types';
+import { BankAccountFormatType } from '../../components/internal/BankAccountFormat/types';
+import Language from '../../language';
+import { CountryCode } from '../models/country-code';
 export interface CoreProviderProps {
-    loadingContext?: string;
-    i18n: any;
-    clientKey?: string;
-    contextCountry?: string;
-    locale?: string;
+    loadingContext: string;
+    clientKey: string;
+    contextCountry: CountryCode;
+    locale: string;
     translations?: any;
-    children?: any;
-    commonProps?: CommonPropsTypes;
     isReview?: boolean;
 }
 export interface CoreProviderState {
     loaded: boolean;
-    i18n: any;
-    contextCountry: string;
-    payoutDefaultCurrency: string;
-    isLegalEntityPartOfTrust: boolean;
-    accountHolder: string;
+    i18n: Language;
+    contextCountry: CountryCode;
+    accountHolder: AccountHolderOption | null;
+    accountFormat: BankAccountFormatType;
 }
 /**
  * CoreProvider Component
  * Wraps a component delaying the render until after the i18n module is fully loaded
  */
-declare class CoreProvider extends Component<CoreProviderProps, CoreProviderState> {
-    state: {
-        loaded: boolean;
-        contextCountry: string;
-        payoutDefaultCurrency: string;
-        i18n: any;
-        isLegalEntityPartOfTrust: boolean;
-        accountHolder: string;
-    };
+export declare class CoreProvider extends Component<CoreProviderProps, CoreProviderState> {
+    constructor(props: CoreProviderProps);
     componentDidMount(): Promise<void>;
-    shouldComponentUpdate(nextProps: any, nextState: any): boolean;
+    shouldComponentUpdate(nextProps: CoreProviderProps, nextState: CoreProviderState): boolean;
     private setContextCountry;
-    private setPayoutDefaultCurrency;
     private setLocale;
-    private setIsLegalEntityPartOfTrust;
     private setAccountHolder;
-    render({ children }: CoreProviderProps): import("preact").JSX.Element;
+    private setAccountFormat;
+    render(props: PropsWithChildren<CoreProviderProps>): import("preact").JSX.Element;
 }
-export default CoreProvider;

package/dist/types/core/Context/ExperimentContext/ExperimentsContext.d.ts

@@ -0,0 +1,2 @@
+import { ExperimentsContextValue } from './types';
+export declare const ExperimentsContext: import("preact").Context<ExperimentsContextValue>;

package/dist/types/core/Context/ExperimentContext/ExperimentsContextProvider.d.ts

@@ -0,0 +1,8 @@
+import { ExperimentsProps } from './types';
+/**
+ * To manage accessing experimental / non-production-ready features of SDK.
+ * Consumers can enable these experimental features if they choose to.
+ * @param children - components rendered
+ * @param experiments - dictionary of type Experiments
+ */
+export declare function ExperimentsContextProvider({ children, experiments }: ExperimentsProps): import("preact").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { ComponentChildren } from 'preact';
+export interface ExperimentsContextValue {
+    isExperimentEnabled(key: ExperimentName): boolean;
+}
+export type Experiments = {
+    [key in ExperimentName]?: boolean;
+};
+export interface ExperimentsProps {
+    children?: ComponentChildren;
+    experiments: Experiments;
+}
+export type ExperimentName = 'EnableTrustFlow';

package/dist/types/core/Context/ExperimentContext/useExperimentsContext.d.ts

@@ -0,0 +1 @@
+export declare function useExperimentsContext(): import("./types").ExperimentsContextValue;

package/dist/types/core/Context/FormRouterContext/FormRouterContext.d.ts

@@ -1 +1,4 @@
-export declare const FormRouterContext: import("preact").Context<any>;
+export declare const FormRouterContext: import("preact").Context<{
+    setFormIndex: (formIndex: number) => void;
+    goToFormByFieldName: (fieldName: string) => void;
+}>;

package/dist/types/core/Context/FormRouterContext/FormRouterContextProvider.d.ts

@@ -1,3 +1,2 @@
 import { FormRouterProps } from './types';
-declare function FormRouterContextProvider({ children, forms, setFormIndex }: FormRouterProps): import("preact").JSX.Element;
-export default FormRouterContextProvider;
+export declare function FormRouterContextProvider({ children, forms, setFormIndex, handleGetIdVerificationToken, }: FormRouterProps): import("preact").JSX.Element;

package/dist/types/core/Context/FormRouterContext/types.d.ts

@@ -1,7 +1,9 @@
 import { ComponentChildren } from 'preact';
-import { Form } from '../../models/form';
+import { DropinAPIHandlers } from '../../../components/Dropins/types';
+import { FormModel } from '../../models/form';
 export interface FormRouterProps {
     children?: ComponentChildren;
     setFormIndex: (formIndex: number) => void;
-    forms: Form[];
+    forms: FormModel[];
+    handleGetIdVerificationToken?: DropinAPIHandlers['handleGetIdVerificationToken'];
 }

package/dist/types/core/Context/FormRouterContext/useFormRouterContext.d.ts

@@ -1,2 +1,4 @@
-declare function useFormRouterContext(): any;
-export default useFormRouterContext;
+export declare function useFormRouterContext(): {
+    setFormIndex: (formIndex: number) => void;
+    goToFormByFieldName: (fieldName: string) => void;
+};

package/dist/types/core/Context/SettingsContext/SettingsContext.d.ts

@@ -1,4 +1,2 @@
-import { SettingName } from './types';
-export declare const SettingsContext: import("preact").Context<{
-    isSettingEnabled: (setting: SettingName) => boolean;
-}>;
+import { SettingsContextValue } from './types';
+export declare const SettingsContext: import("preact").Context<SettingsContextValue>;

package/dist/types/core/Context/SettingsContext/SettingsContextProvider.d.ts

@@ -1,3 +1,8 @@
 import { SettingsProps } from './types';
-declare function SettingsContextProvider({ children, settings }: SettingsProps): import("preact").JSX.Element;
-export default SettingsContextProvider;
+/**
+ * To manage accessing mature features of SDK,
+ * which consumers can hide based on their onboarding requirements
+ * @param children - components rendered
+ * @param experiments - dictionary of type Settings
+ */
+export declare function SettingsContextProvider({ children, settings }: SettingsProps): import("preact").JSX.Element;

package/dist/types/core/Context/SettingsContext/types.d.ts

@@ -1,9 +1,12 @@
 import { ComponentChildren } from 'preact';
-export declare type Settings = {
+export type Settings = {
     [key in SettingName]?: boolean;
 };
 export interface SettingsProps {
     children?: ComponentChildren;
     settings: Settings;
 }
-export declare type SettingName = 'editPrefilledCountry' | 'changeLegalEntityType' | 'enableTrustFlow';
+export interface SettingsContextValue {
+    isSettingEnabled(key: SettingName): boolean;
+}
+export type SettingName = 'editPrefilledCountry' | 'changeLegalEntityType' | 'allowIntraRegionCrossBorderPayout' | 'allowBankAccountFormatSelection';

package/dist/types/core/Context/SettingsContext/useSettingsContext.d.ts

@@ -1,4 +1 @@
-declare function useSettingsContext(): {
-    isSettingEnabled: (setting: import("./types").SettingName) => boolean;
-};
-export default useSettingsContext;
+export declare function useSettingsContext(): import("./types").SettingsContextValue;

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

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

package/dist/types/core/Context/StateContext/StateProvider.d.ts

@@ -1,5 +1,4 @@
-declare function StateProvider({ defaultData, children }: {
+export declare function StateProvider({ defaultData, children }: {
     defaultData?: {};
     children: any;
 }): import("preact").JSX.Element;
-export default StateProvider;

package/dist/types/core/Context/StateContext/StateReducer.d.ts

@@ -1,6 +1,6 @@
 import { SCAction } from './types';
 export declare function StateReducer(): {
-    reducer: ({ currentState: state }: {
+    reducer: ({ currentState: currState }: {
         currentState: any;
     }, action: SCAction) => {
         currentState: any;

package/dist/types/core/Context/StateContext/hasDataChanged.d.ts

@@ -0,0 +1 @@
+export declare const hasDataChanged: <T extends object>(initialData: T, currentData: T) => boolean;

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

@@ -1,9 +1,11 @@
-import { IndividualSchema } from '../../../components/Individual/types';
 import { CompanySchema } from '../../../components/Company/types';
-import { TrustSchema } from '../../../components/Trust/types';
+import { TrustMemberSchema } from '../../../components/Dropins/RoleAndTypeDropin/types';
+import { IndividualSchema } from '../../../components/Individual/types';
 import { PayoutDetailsSchema } from '../../../components/PayoutDetails/types';
+import { SolePropSchema } from '../../../components/SoleProp/types';
+import { TrustSchema } from '../../../components/Trust/types';
 export interface SFValue {
-    caller: string;
+    caller?: string;
     data?: object;
     valid?: object;
     errors?: object;
@@ -15,8 +17,8 @@ export interface SCAction {
     type: 'addToState' | 'resetState';
     value?: SFValue;
 }
-interface SCCurrent {
-    setState: (action: SCAction) => void;
+export interface SCCurrent {
+    setState: null | ((action: SCAction) => void);
     setActiveForms?: (forms: string[]) => void;
 }
 export interface StateContextRef {
@@ -35,8 +37,9 @@ export interface SCWatcher extends StateContextBase {
         changeInitiatedBy: any;
     }) => void;
 }
-export declare type StateModel<TLDS extends TopLevelDataSchema = TopLevelDataSchema> = {
+export type StateModel<TLDS extends TopLevelDataSchema = TopLevelDataSchema> = {
     getData: () => TLDS;
+    getState: () => State<TLDS>;
     dispatch: (action: SCAction) => void;
     setActiveForms: (forms: string[]) => void;
     state: {
@@ -44,7 +47,7 @@ export declare type StateModel<TLDS extends TopLevelDataSchema = TopLevelDataSch
         prevState?: State<TLDS>;
     };
 };
-export declare type TopLevelDataSchema = IndividualSchema | CompanySchema | PayoutDetailsSchema | TrustSchema;
+export type TopLevelDataSchema = IndividualSchema | CompanySchema | PayoutDetailsSchema | TrustSchema | TrustMemberSchema | SolePropSchema;
 export interface State<TLDS extends TopLevelDataSchema> {
     data: TLDS;
     allData: TLDS;
@@ -54,6 +57,9 @@ export interface State<TLDS extends TopLevelDataSchema> {
     allValid: boolean;
     isValid: boolean;
     validityByForm?: Record<string, boolean>;
+    initialData: TLDS;
+    hasDataChanged: Record<keyof TLDS, boolean>;
+    hasAnyDataChanged: boolean;
 }
 export interface StateSlice<TLDS extends TopLevelDataSchema, SliceName extends keyof TLDS> {
     data?: TLDS[SliceName];
@@ -66,6 +72,5 @@ export interface StateSlice<TLDS extends TopLevelDataSchema, SliceName extends k
     fieldProblems?: {
         [key in keyof TLDS[SliceName]]: any;
     };
-    schema?: readonly (keyof TLDS[SliceName])[];
+    schema?: ReadonlyArray<keyof TLDS[SliceName]>;
 }
-export {};

package/dist/types/core/Context/StateContext/useGlobalData.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="lodash" />
+import { StateSlice, TopLevelDataSchema } from './types';
+export declare function useGlobalData<TLDS extends TopLevelDataSchema>(): TLDS;
+export declare function useGlobalDataSlice<TLDS extends TopLevelDataSchema, SliceName extends keyof TLDS>(sliceId: SliceName, caller?: string): {
+    sliceData: TLDS[SliceName];
+    updateStateSlice: import("lodash").DebouncedFunc<(updatedSlice: StateSlice<TLDS, SliceName>) => void>;
+};
+export declare function useResetGlobalData<TLDS extends TopLevelDataSchema>(caller?: string): () => void;

package/dist/types/core/Context/StateContext/useStateContext.d.ts

@@ -1,3 +1,2 @@
 import { StateModel, TopLevelDataSchema } from './types';
-declare function useStateContext<TLDS extends TopLevelDataSchema>(): StateModel<TLDS>;
-export default useStateContext;
+export declare function useStateContext<TLDS extends TopLevelDataSchema>(): StateModel<TLDS>;

package/dist/types/core/Context/ToastContext/ToastContext.d.ts

@@ -1 +1,6 @@
-export declare const ToastContext: import("preact").Context<any>;
+import { ToastOptions } from '../../../components/internal/Toast';
+export interface ToastContextValue {
+    showToast: (options: ToastOptions) => void;
+    clearToasts: () => void;
+}
+export declare const ToastContext: import("preact").Context<ToastContextValue>;

package/dist/types/core/Context/ToastContext/ToastContextProvider.d.ts

@@ -1,4 +1,4 @@
-declare function ToastContextProvider({ children }: {
-    children: any;
+import { ComponentChildren } from 'preact';
+export declare function ToastContextProvider({ children }: {
+    children: ComponentChildren;
 }): import("preact").JSX.Element;
-export default ToastContextProvider;

package/dist/types/core/Context/ToastContext/useToastContext.d.ts

@@ -1,2 +1,2 @@
-declare function useToastContext(): any;
-export default useToastContext;
+import { ToastContextValue } from './ToastContext';
+export declare function useToastContext(): ToastContextValue;

package/dist/types/core/Context/useCoreContext.d.ts

@@ -1,18 +1 @@
-declare const useCoreContext: () => {
-    i18n: import("../../language/Language").default;
-    translations: any;
-    setLocale: any;
-    loadingContext: string;
-    clientKey: string;
-    setContextCountry: any;
-    contextCountry: string;
-    setPayoutDefaultCurrency: any;
-    payoutDefaultCurrency: string;
-    commonProps: import("./CoreProvider").CommonPropsTypes;
-    isReview: boolean;
-    isLegalEntityPartOfTrust: boolean;
-    setIsLegalEntityPartOfTrust: any;
-    setAccountHolder: any;
-    accountHolder: string;
-};
-export default useCoreContext;
+export declare const useCoreContext: () => import("./CoreContext").CoreContextType;

package/dist/types/core/SDKValidation/index.d.ts

@@ -1,5 +1,4 @@
-import { ComponentMap } from '../../components';
+import { ComponentOptions } from '../../components';
 import { CoreOptions } from '../types';
-export declare const validateForm: (formName: keyof ComponentMap) => void;
-export declare const validateInitializationOptions: (coreOptions: CoreOptions) => void;
-export declare const validateOptions: (formName: keyof ComponentMap, options: any) => void;
+export declare const validateCoreOptions: (coreOptions: CoreOptions) => void;
+export declare const validateForComponent: <Name extends "payoutAccount" | "taskList" | "pci" | "individualDropin" | "companyDropin" | "trustDropin" | "soleProprietorDropin">(componentName: Name, options: ComponentOptions<Name>) => void;

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

@@ -1,14 +1,19 @@
-import { ComponentMap } from '../../components';
-export declare type PropertiesSchema = {
-    [key: string]: {
-        required?: boolean;
-        type: string;
-        exactValue?: string | string[];
-        propertiesSchema?: PropertiesSchema;
-    };
+import { ComponentMap, ComponentPropsWithoutEventEmitter } from '../../components';
+interface ValueSchema<T> {
+    required?: boolean;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'function';
+    exactValue?: T | T[];
+}
+interface ObjectSchema<T> {
+    required?: boolean;
+    type: 'object';
+    propertiesSchema?: PropertiesSchema<NonNullable<T>>;
+}
+export type PropertySchema<T> = ValueSchema<T> | ObjectSchema<T>;
+export type PropertiesSchema<T> = {
+    [Key in keyof T]: PropertySchema<NonNullable<T[Key]>>;
 };
-export declare type ComponentsSchemaMap = {
-    [key in keyof ComponentMap]: {
-        propertiesSchema?: PropertiesSchema;
-    };
+export type ComponentsSchemaMap = {
+    [ComponentName in keyof ComponentMap]: PropertiesSchema<ComponentPropsWithoutEventEmitter<ComponentName>>;
 };
+export {};

package/dist/types/core/Services/get-account-format.d.ts

@@ -0,0 +1,4 @@
+import { GetPayoutAccountFormatResponse } from '../models/api/get-account-format';
+import { CountryCode } from '../models/country-code';
+import { RequestContext } from './types';
+export declare const getPayoutAccountFormat: (context: RequestContext, country: CountryCode) => Promise<GetPayoutAccountFormatResponse>;

package/dist/types/core/Services/get-allowed-countries.d.ts

@@ -0,0 +1,3 @@
+import { GetAllowedCountriesResponse } from '../models/api/get-allowed-countries';
+import { RequestContext } from './types';
+export declare const getAllowedCountries: (context: RequestContext) => Promise<GetAllowedCountriesResponse>;

package/dist/types/core/Services/get-allowed-locales.d.ts

@@ -0,0 +1,3 @@
+import { GetAllowedLocalesResponse } from '../models/api/get-allowed-locales';
+import { RequestContext } from './types';
+export declare const getAllowedLocales: (context: RequestContext) => Promise<GetAllowedLocalesResponse>;

package/dist/types/core/Services/get-configuration.d.ts

@@ -0,0 +1,3 @@
+import type { GetConfigurationRequest, GetConfigurationResponse } from '../models/api/get-configuration';
+import { RequestContext } from './types';
+export declare const getConfiguration: (context: RequestContext, request: GetConfigurationRequest) => Promise<GetConfigurationResponse>;

package/dist/types/core/Services/get-dataset.d.ts

@@ -1,2 +1,3 @@
 import { DataSet } from '../models/api/data-set';
-export default function getDataset(name: string, loadingContext: any, locale: any, clientKey: any): Promise<DataSet>;
+import { RequestContext } from './types';
+export declare const getDataset: (context: RequestContext, name: string, locale: string) => Promise<DataSet>;

package/dist/types/core/Services/get-images.d.ts

@@ -1,3 +1,2 @@
-declare function loadFlags(loadingContext?: string): Promise<void>;
-declare function loadDocumentGuidance(loadingContext?: string): Promise<void>;
-export { loadFlags, loadDocumentGuidance };
+export declare const loadFlags: (loadingContext: string) => Promise<void>;
+export declare const loadDocumentGuidance: (loadingContext?: string) => Promise<void>;

package/dist/types/core/Services/http.d.ts

@@ -1,16 +1,4 @@
-interface HttpOptions {
-    accept?: string;
-    contentType?: string;
-    errorMessage?: string;
-    headers?: any;
-    loadingContext?: string;
-    clientKey?: string;
-    method?: string;
-    path: string;
-    errorLevel?: 'silent' | 'info' | 'warn' | 'error' | 'fatal';
-    errorHandler?: (response: any) => any;
-}
-export declare function http<T>(options: HttpOptions, data?: any, responseType?: XMLHttpRequestResponseType): Promise<T>;
-export declare function httpGet<T>(options: HttpOptions, data?: any): Promise<T>;
-export declare function httpPost<T>(options: HttpOptions, data?: any): Promise<T>;
-export {};
+import { HttpOptions } from './types';
+export declare const http: <T>(options: HttpOptions, data?: any, responseType?: XMLHttpRequestResponseType) => Promise<T>;
+export declare const httpGet: <T>(options: HttpOptions, data?: any) => Promise<T>;
+export declare const httpPost: <T>(options: HttpOptions, data?: any) => Promise<T>;

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

@@ -0,0 +1,16 @@
+import { CoreContextType } from '../Context/CoreContext';
+export type FetchErrorLevel = 'silent' | 'info' | 'warn' | 'error' | 'fatal';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'OPTIONS' | 'PATCH';
+export type RequestContext = Partial<CoreContextType> & Required<Pick<CoreContextType, 'loadingContext' | 'clientKey'>>;
+export interface HttpOptions {
+    accept?: string;
+    contentType?: string;
+    errorMessage?: string;
+    headers?: HeadersInit;
+    loadingContext?: string;
+    clientKey?: string;
+    method?: HttpMethod;
+    path: string;
+    errorLevel?: FetchErrorLevel;
+    errorHandler?: (response: any) => any;
+}

package/dist/types/core/Services/utils.d.ts

@@ -0,0 +1,5 @@
+import { FetchErrorLevel, HttpOptions } from './types';
+export declare const getRequestObject: (options: HttpOptions, data?: any) => RequestInit;
+export declare const getRequestUrl: (loadingContext: string, path: string, clientKey: string) => string;
+export declare const handleFetchError: (message: string, level: FetchErrorLevel) => void;
+export declare const handleFetchResponse: (response: Response, responseType: XMLHttpRequestResponseType) => Promise<any>;

package/dist/types/core/Services/validate-phone-number.d.ts

@@ -0,0 +1,3 @@
+import { ValidationResponse } from '../models/errors/validation-error';
+import { RequestContext } from './types';
+export declare const validatePhoneNumber: (context: RequestContext, phoneNumber: string) => Promise<ValidationResponse>;

package/dist/types/core/Services/verify-id-number.d.ts

@@ -1,2 +1,3 @@
-import IdVerificationData from '../models/api/id-verification-data';
-export declare const verifyIDNumber: (loadingContext: string, clientKey: string, dataObj: any) => Promise<IdVerificationData>;
+import { VerifyIdNumberRequest, VerifyIdNumberResponse } from '../models/api/verify-id-number';
+import { RequestContext } from './types';
+export declare const verifyIdNumber: (context: RequestContext, request: VerifyIdNumberRequest) => Promise<VerifyIdNumberResponse | undefined>;

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

@@ -1,10 +1,11 @@
 export declare const ON_CHANGE_DEBOUNCE_DURATION = 200;
 export declare const KEYBOARD_KEYS: {
-    arrowDown: string;
-    arrowUp: string;
-    enter: string;
-    escape: string;
-    space: string;
-    tab: string;
+    readonly arrowDown: "ArrowDown";
+    readonly arrowUp: "ArrowUp";
+    readonly enter: "Enter";
+    readonly escape: "Escape";
+    readonly space: " ";
+    readonly tab: "Tab";
 };
-export declare const API_VALIDATION_ERROR_CODE = "30_102";
+export type KeyboardKeyLabel = keyof typeof KEYBOARD_KEYS;
+export type KeyboardKey = (typeof KEYBOARD_KEYS)[KeyboardKeyLabel];

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

@@ -1,49 +1,26 @@
-import Language from '../language';
+import { ComponentOptions } from '../components';
+import { BaseElement } from '../components/BaseElement';
+import { UIElement } from '../components/UIElement';
 import { CoreOptions } from './types';
-import { ComponentMap, ComponentOptions } from '../components';
-import UIElement from '../components/UIElement';
-interface Modules {
-    i18n: Language;
-}
-declare class Core {
+export declare class Core {
     options: CoreOptions & {
         loadingContext: string;
     };
     components: UIElement[];
-    modules: Modules;
-    static readonly version: {
-        version: string;
-        revision: string;
-        branch: string;
-        buildId: string;
-    };
     constructor(coreOptions: CoreOptions);
-    create: <Name extends "individual" | "payoutAccount" | "personalDetails" | "address" | "contactDetails" | "company" | "individualDropin" | "companyDropin" | "taskList" | "trustDropin">(formName: Name, options: ComponentOptions<Name>) => {
-        readonly individualDropin: typeof import("../components/Dropins").IndividualDropin;
-        readonly individual: typeof import("../components/Individual").default;
-        readonly personalDetails: typeof import("../components/PersonalDetails").default;
-        readonly address: typeof import("../components/Address").default;
-        readonly contactDetails: typeof import("../components/ContactDetails").default;
-        readonly company: typeof import("../components/Company").default;
-        readonly companyDropin: typeof import("../components/Dropins/CompanyDropin").CompanyDropin;
-        readonly taskList: typeof import("../components/Dropins/DropinComposer/DropinComposer").DropinComposer;
-        readonly payoutAccount: typeof import("../components/Dropins/PayoutDetailsDropin/PayoutDetailsDropin").PayoutDetailsDropin;
-        readonly trustDropin: typeof import("../components/Dropins/TrustDropin").CompanyDropin;
-    }[Name];
-    createForm<Name extends keyof ComponentMap>(formName: Name, options: ComponentOptions<Name>): ComponentMap[Name];
+    create: <Name extends "payoutAccount" | "taskList" | "pci" | "individualDropin" | "companyDropin" | "trustDropin" | "soleProprietorDropin">(componentName: Name, componentOptions: ComponentOptions<Name>) => UIElement;
     /**
      * Updates global configurations, resets the internal state and remounts each element.
      * @param options - props to update
      * @returns this - the element instance
      */
-    update: (options: CoreOptions) => this;
-    updateLocale: (options: any) => this;
+    update: (options: Partial<CoreOptions>) => this;
+    updateLocale: ({ locale }: Pick<CoreOptions, 'locale'>) => this;
     /**
      * Remove the reference of a component
      * @param component - reference to the component to be removed
      * @returns this - the element instance
      */
-    remove: (component: any) => this;
-    private setOptions;
+    remove: (component: BaseElement<object>) => this;
+    private getUpdatedOptions;
 }
-export default Core;

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

@@ -1,4 +1,4 @@
-export default class AdyenKycSdkError extends Error {
+export declare class AdyenKycSdkError extends Error {
     sourceError: any;
     constructor(message: string, sourceError?: Error);
 }

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

@@ -1,3 +1,4 @@
 import { RemediationCode } from './models/errors/remediation';
-import RemediationActionContext from './models/errors/remediation-action-context';
+import { RemediationActionContext } from './models/errors/remediation-action-context';
 export declare const remediationActionMappings: Partial<Record<RemediationCode, RemediationActionContext[]>>;
+export declare const dataMissingRemediationsToFieldsMap: Partial<Record<RemediationCode, string[]>>;

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

@@ -0,0 +1,11 @@
+import { AsyncValidatorRules, ValidatorMode } from '../../utils/validation/types';
+import { ValidationResult } from '../../utils/validation/ValidationResult';
+import { FormState } from './useForm/types';
+export type AsyncValidationResults<FormSchema> = Partial<Record<keyof FormSchema, ValidationResult>>;
+export type AsyncValidate<FormSchema> = (field: keyof FormSchema, formState: FormState<FormSchema>, mode: ValidatorMode) => void;
+export type UseAsyncValidator<FormSchema> = {
+    asyncValidate: AsyncValidate<FormSchema>;
+    asyncValidationResults: AsyncValidationResults<FormSchema>;
+    clearAsyncValidationResults: () => void;
+};
+export declare const useAsyncValidator: <FormSchema>(asyncRules?: Partial<{ [field in keyof FormSchema]: import("../../utils/validation/types").AsyncValidatorRule<FormSchema[field], FormSchema>; }>) => UseAsyncValidator<FormSchema>;

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

@@ -0,0 +1,9 @@
+import { ComponentChildren, ComponentProps } from 'preact';
+import { MutableRef } from 'preact/hooks';
+export declare function useClickAwayListener(ref: MutableRef<HTMLElement | null>, onClickAway: () => void): void;
+interface ClickAwayWrapperProps extends ComponentProps<'div'> {
+    children: ComponentChildren;
+    onClickAway: () => void;
+}
+export declare const ClickAwayWrapper: ({ children, onClickAway, ...divProps }: ClickAwayWrapperProps) => import("preact").JSX.Element;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './reducer';
+export * from './types';
+export * from './useForm';