@adyen/kyc-components 1.6.2 → 2.0.0

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/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> = {
+    asyncValidationResults: AsyncValidationResults<FormSchema>;
+    asyncValidate: AsyncValidate<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';

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

@@ -0,0 +1,6 @@
+import { FormState, InitFormStateOptions, ProcessFieldOptions, ProcessFieldResult, ReducerAction } from './types';
+/**
+ * Processes default data and sets initial state
+ */
+export declare function init<FormSchema>({ schema, defaultData, processField, fieldProblems, maskedFields, }: InitFormStateOptions<FormSchema>): FormState<FormSchema>;
+export declare function getReducer<FormSchema>(processField: <Field extends keyof FormSchema>(options: ProcessFieldOptions<FormSchema, Field>) => ProcessFieldResult): (state: FormState<FormSchema>, { type, key, value, mode, schema, defaultData, formValue, selectedSchema, maskedFields, fieldProblems, }: ReducerAction<FormSchema>) => FormState<FormSchema>;

package/dist/types/{utils → core/hooks}/useForm/types.d.ts

@@ -1,22 +1,31 @@
-import { ValidatorRules } from '../Validator/types';
-import { EntityProblems } from '../../core/models/errors/entity-problems';
-import { FormVerificationErrors } from '../../core/models/errors/form-verification-errors';
-import { TranslationKey } from '../../language/types';
 import { StateUpdater } from 'preact/hooks';
-export declare type FormState<FormSchema> = {
-    schema?: (keyof FormSchema)[];
+import { TranslationKey } from '../../../language/types';
+import { FieldContext, FormatRules, ValidationRuleResult, ValidatorMode, ValidatorRules } from '../../../utils/validation/types';
+import { ValidationResult } from '../../../utils/validation/ValidationResult';
+import { CountryCode } from '../../models/country-code';
+import { EntityProblems } from '../../models/errors/entity-problems';
+import { FormVerificationErrors } from '../../models/errors/form-verification-errors';
+import { FormModel } from '../../models/form';
+export type FormState<FormSchema> = {
+    schema?: Array<keyof FormSchema>;
     data: FormSchema;
-    errors: {
-        [key in keyof FormSchema]: any;
-    };
-    valid: {
-        [key in keyof FormSchema]: boolean;
-    };
-    fieldProblems?: {
-        [key in keyof FormSchema]: any;
-    };
+    errors: Record<keyof FormSchema, ValidationRuleResult>;
+    valid: Record<keyof FormSchema, boolean>;
+    fieldProblems?: Record<keyof FormSchema, any>;
+    maskedFields?: Array<keyof FormSchema>;
     isValid?: boolean;
+    dataStoreId?: string;
+    local?: any;
 };
+export interface Form<FormSchema> extends FormState<FormSchema> {
+    handleChangeFor: <Field extends keyof FormSchema>(key: Field, mode?: ValidatorMode) => (e: any) => void;
+    triggerValidation: <Field extends keyof FormSchema>(schema?: Field[]) => void;
+    setData: <K extends keyof FS, FS extends FormSchema = FormSchema>(key: K, value: FS[K]) => void;
+    setValid: <FS extends FormSchema = FormSchema>(key: keyof FS, value: boolean) => void;
+    setErrors: <FS extends FormSchema = FormSchema>(key: keyof FS, value: any) => void;
+    mergeForm: (formValue: any) => void;
+    setFieldProblems: (fieldProblems: any) => void;
+}
 export interface BaseFormProps<FormSchema> {
     placeholders?: {
         [field in keyof FormSchema]: TranslationKey;
@@ -41,27 +50,18 @@ export interface BaseFormProps<FormSchema> {
         [field in keyof FormSchema]: any;
     };
     onChange?(state: FormState<FormSchema>): void;
-    showValidation?: boolean;
     data?: FormSchema;
     validators?: ValidatorRules<FormSchema>;
     ref?: any;
     heading?: string;
     name?: string;
     description?: string;
-}
-export interface Form<FormSchema> extends FormState<FormSchema> {
-    handleChangeFor: <FS extends FormSchema = FormSchema>(key: keyof FS, mode?: string) => (e: any) => void;
-    triggerValidation: <FS extends FormSchema = FormSchema>(schema?: (keyof FS)[]) => void;
-    setData: <K extends keyof FS, FS extends FormSchema = FormSchema>(key: K, value: FS[K]) => void;
-    setValid: <FS extends FormSchema = FormSchema>(key: keyof FS, value: boolean) => void;
-    setErrors: (key: string, value: any) => void;
-    mergeForm: (formValue: any) => void;
-    setFieldProblems: (fieldProblems: any) => void;
+    shouldValidate?: boolean;
 }
 export interface BaseOuterFormProps<FormSchema> extends BaseFormProps<FormSchema> {
     problems?: EntityProblems;
-    capabilities?: Array<string>;
-    country?: string;
+    capabilities?: string[];
+    country?: CountryCode;
     requiredFields?: {
         [field in keyof FormSchema]: any;
     };
@@ -78,6 +78,7 @@ export interface BaseOuterFormProps<FormSchema> extends BaseFormProps<FormSchema
         [field in keyof FormSchema]: any;
     };
     evaluateConfiguration?: (data: FormSchema) => void;
+    activeForm?: FormModel;
     setHideDropinLayout?: StateUpdater<boolean>;
     setHideNavigation?: StateUpdater<boolean>;
     setHideFooter?: StateUpdater<boolean>;
@@ -89,9 +90,7 @@ export interface BaseOuterFormProps<FormSchema> extends BaseFormProps<FormSchema
 }
 export interface BaseInnerFormProps<FormSchema> extends BaseFormProps<FormSchema> {
     formVerificationErrors?: FormVerificationErrors;
-    fieldValidationErrors?: {
-        [fieldName: string]: any;
-    };
+    fieldValidationErrors?: Record<keyof FormSchema, any>;
     requiredFields?: Array<keyof FormSchema>;
     maskedFields?: Array<keyof FormSchema>;
     optionalFields?: Array<keyof FormSchema>;
@@ -99,4 +98,35 @@ export interface BaseInnerFormProps<FormSchema> extends BaseFormProps<FormSchema
     readOnlyFields?: Array<keyof FormSchema>;
     id?: string;
     dataStoreId?: string;
+    capabilities?: string[];
+}
+export interface ProcessFieldOptions<FormSchema, Field extends keyof FormSchema> {
+    key: Field;
+    value: FormSchema[Field];
+    mode: ValidatorMode;
+    defaultData: Partial<FormSchema>;
+    maskedFields?: Array<keyof FormSchema>;
+    fieldContext: FieldContext<FormSchema>;
+}
+export type ProcessFieldResult = [any, ValidationResult];
+export interface InitFormStateOptions<FormSchema> {
+    schema: Array<keyof FormSchema>;
+    defaultData: Partial<FormSchema>;
+    processField: <Field extends keyof FormSchema>(options: ProcessFieldOptions<FormSchema, Field>) => ProcessFieldResult;
+    maskedFields?: Array<keyof FormSchema>;
+    fieldProblems?: Record<keyof FormSchema, any>;
+    formatters?: FormatRules<FormSchema>;
+}
+export type ReducerActionType = 'setData' | 'setValid' | 'setErrors' | 'setFieldProblems' | 'updateField' | 'mergeForm' | 'setSchema' | 'validateForm';
+export interface ReducerAction<FormSchema> {
+    type: ReducerActionType;
+    key?: keyof FormSchema;
+    value?: any;
+    mode?: ValidatorMode;
+    schema?: Array<keyof FormSchema>;
+    defaultData?: FormSchema | Partial<FormSchema>;
+    formValue?: any;
+    selectedSchema?: Array<keyof FormSchema>;
+    maskedFields?: Array<keyof FormSchema>;
+    fieldProblems?: Record<keyof FormSchema, any>;
 }