@adyen/kyc-components 2.2.4 → 2.2.6

package/dist/types/core/models/decision-maker.d.ts

@@ -0,0 +1,55 @@
+import { TranslationKey } from '../../language/types';
+import { DecisionMakerType } from './api/decision-maker-type';
+/**
+ *
+ * When providing DECISION_MAKER_REQUIREMENTS per country - keep in mind that you need to specify rules for each role individually even if you have a mixed rule between them.
+ * If you don't provide rules for a given individual role, it means that country does not support that type of decision maker and will not be returned by `getAvailableDecisionMakerRoleTypes(country)`.
+ *
+ * This give us more flexibility to have:
+ * 1- rules for each role
+ * 2- different rules for mixed roles if there's any
+ *
+ * Examples
+ * A- provide at most 4 (controlling person - or - owners) but at least it should have 1 owner ...
+ * B- provide at least 1 (controlling person - or - an owner) but max 4 owners and no max for controlling ...
+ *
+ * @example
+ * let's say we want to write the config for the above [example B] it should look like this:
+ * ```
+ * [
+ *     {
+ *         // === the mixed rule  ===
+ *         roleTypes: [DecisionMakerType.CONTROLLING_PERSON, DecisionMakerType.OWNER],
+ *          min: 1,
+ *          max: Infinity
+ *      },
+ *      {
+ *          // === specify each individually ===
+ *          roleTypes: [DecisionMakerType.OWNER],
+ *          min: 0,
+ *          max: 4
+ *      },
+ *      {
+ *          // === specify each individually ===
+ *          roleTypes: [DecisionMakerType.CONTROLLING_PERSON],
+ *          min: 0,
+ *          max: Infinity
+ *      }
+ * ]
+ * ```
+ *
+ * each of the rules have different max to apply.
+ *
+ * */
+export interface DecisionMakerRequirement {
+    roleTypes: readonly DecisionMakerType[];
+    min: number;
+    max: number;
+}
+export declare const getDecisionMakerRequirements: (country: string) => readonly DecisionMakerRequirement[];
+export declare function getAvailableDecisionMakerRoleTypes(country: string): {
+    roleType: DecisionMakerType;
+    min: number;
+    max: number;
+}[];
+export declare const getDecisionMakerDescriptionMap: (country: string) => Record<DecisionMakerType, TranslationKey>;

package/dist/types/core/models/errors/capability-problems.d.ts

@@ -0,0 +1,7 @@
+import { EntityType } from '../api/entity-type';
+import { EntityProblems } from './entity-problems';
+export type CapabilityProblems = {
+    [entityType in EntityType]: {
+        [entityId: string]: EntityProblems;
+    };
+};

package/dist/types/core/models/errors/entity-problems.d.ts

@@ -0,0 +1,21 @@
+import { TaskStatus } from '../../../components/TaskList/types';
+import { EntityType } from '../api/entity-type';
+import { LegalEntityType } from '../api/legal-entity-type';
+import { VerificationError } from '../api/verification-error';
+import { FormVerificationErrors } from './form-verification-errors';
+import { Remediation, RemediationCode } from './remediation';
+export type EntityProblems = {
+    verificationErrors: {
+        [formId: string]: FormVerificationErrors;
+    };
+    remediationActions: Partial<Record<RemediationCode, Remediation>>;
+    status: TaskStatus;
+    missingData: VerificationError[];
+    validationErrors?: {
+        [formId: string]: {
+            [fieldName: string]: boolean;
+        };
+    };
+    entityType?: LegalEntityType | EntityType.BANK_ACCOUNT;
+    isReviewRequired?: boolean;
+};

package/dist/types/core/models/errors/error-message.d.ts

@@ -0,0 +1,7 @@
+import { TranslationKey } from '../../../language/types';
+export type ErrorCode = Extract<TranslationKey, `errorMessage_${string}`> extends `errorMessage_${infer R}` ? R : never;
+export interface ErrorMessage {
+    code: ErrorCode;
+    errorMessage: string;
+    remediationMessages?: string[];
+}

package/dist/types/core/models/errors/form-verification-errors.d.ts

@@ -0,0 +1,3 @@
+import { ErrorCode } from './error-message';
+import { Remediation } from './remediation';
+export type FormVerificationErrors = Partial<Record<ErrorCode, Partial<Record<ErrorCode, Remediation[]>>>>;

package/dist/types/core/models/errors/maintenance-mode-error.d.ts

@@ -0,0 +1,7 @@
+export interface MaintenanceModeError {
+    message: string;
+    messageCode: 'maintenanceMode';
+    reference: string;
+    statusCode: 503;
+}
+export declare const isMaintenanceModeError: (error: Error | undefined) => boolean;

package/dist/types/core/models/errors/remediation-action-context.d.ts

@@ -0,0 +1,4 @@
+export interface RemediationActionContext {
+    key: string;
+    type?: string[];
+}

package/dist/types/core/models/errors/remediation.d.ts

@@ -0,0 +1,7 @@
+import { TranslationKey } from '../../../language/types';
+export type RemediationCode = Extract<TranslationKey, `remediationMessage_${string}`> extends `remediationMessage_${infer R}` ? R : never;
+export interface Remediation {
+    code: RemediationCode;
+    forms: string[];
+    fields?: string[];
+}

package/dist/types/core/models/errors/validation-error.d.ts

@@ -0,0 +1,19 @@
+export interface InvalidField {
+    name: string;
+    value: any;
+    message: string;
+}
+export interface ValidationError {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    requestId: string;
+    invalidFields: InvalidField[];
+    errorCode: string;
+}
+export declare const isValidationError: (error: Error | undefined) => boolean;
+export interface ValidationResponse {
+    invalidFields: InvalidField[];
+    valid: boolean;
+}

package/dist/types/core/models/field-configurations.d.ts

@@ -0,0 +1,8 @@
+import { CountryFieldConfig } from './country-config';
+import { ScenarioFieldSettings } from './scenario-fields';
+interface FieldConfiguration<FieldType> extends ScenarioFieldSettings<FieldType>, CountryFieldConfig {
+}
+export type FieldConfigurations<FormSchema> = {
+    [key in keyof FormSchema]: FieldConfiguration<FormSchema[key]>;
+};
+export {};

package/dist/types/core/models/form-labels.d.ts

@@ -0,0 +1,5 @@
+export type FormLabels = (data: {
+    [key: string]: any;
+}, country: string) => {
+    [key: string]: () => string | null;
+};

package/dist/types/core/models/form-rules.d.ts

@@ -0,0 +1,15 @@
+import { TaskTypes } from '../../components/TaskList/types';
+import { SettingName } from '../Context/SettingsContext/types';
+import { TopLevelDataSchema } from '../Context/StateContext/types';
+import { PayoutRequiredFields } from './api/get-configuration';
+import { CountryCode } from './country-code';
+export interface FormRulesParams<TLDS extends TopLevelDataSchema> {
+    data: TLDS;
+    country: CountryCode;
+    taskType: TaskTypes;
+    isSettingEnabled?: (setting: SettingName) => boolean;
+    requiredFields?: Partial<PayoutRequiredFields>;
+}
+export type FormRules<TLDS extends TopLevelDataSchema> = (params: FormRulesParams<TLDS>) => {
+    [ruleName: string]: () => string | boolean | undefined;
+};

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

@@ -0,0 +1,18 @@
+import { TranslationKey } from '../../language/types';
+export interface FormModel {
+    formId: string;
+    formName: TranslationKey;
+    fields?: any[];
+    hideNavigation?: boolean;
+    hideActionBar?: boolean;
+    verifyForm?(formId?: string): Promise<boolean>;
+    triggerValidation?(): void;
+    customNavigationHandler?(): void;
+}
+export interface FormModelWithValidity extends FormModel {
+    isValid: boolean;
+    hasServerValidationErrors?: boolean;
+}
+export interface FormList {
+    [field: string]: FormModel;
+}

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

@@ -0,0 +1,7 @@
+import { VerifyIdNumberResponse } from './api/verify-id-number';
+export interface IdVerificationStatus {
+    status: string;
+    data: VerifyIdNumberResponse;
+    fieldName: string;
+    translationKey?: string;
+}

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

@@ -0,0 +1,41 @@
+import { AdditionalIdentityInfoSchema } from '../../components/IdentityAu/additionalIdentityInfoSchema';
+import { CountryConfig } from './country-config';
+import { ScenarioFieldSettings } from './scenario-fields';
+export declare const identityBase: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const identityNumber: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const additionalIdentityInfo: Record<keyof AdditionalIdentityInfoSchema, ScenarioFieldSettings>;
+export declare const idDocument: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const nationality: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const fieldsPerScenario: {
+    L0: any;
+    L1: {
+        [key: string]: ScenarioFieldSettings<unknown>;
+    };
+    L1_ID: {
+        issuerState: ScenarioFieldSettings<unknown>;
+        licenseCardNumber: ScenarioFieldSettings<unknown>;
+        typeOfIdentity: ScenarioFieldSettings<unknown>;
+    };
+    L1_IDO: {
+        issuerState: ScenarioFieldSettings<unknown>;
+        licenseCardNumber: ScenarioFieldSettings<unknown>;
+        typeOfIdentity: ScenarioFieldSettings<unknown>;
+    };
+    L1_NAT: {
+        issuerState: ScenarioFieldSettings<unknown>;
+        licenseCardNumber: ScenarioFieldSettings<unknown>;
+        typeOfIdentity: ScenarioFieldSettings<unknown>;
+    };
+    L1_IDDOC: {
+        [key: string]: ScenarioFieldSettings<unknown>;
+    };
+};
+export declare const countryConfig: CountryConfig;

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

@@ -0,0 +1,11 @@
+import { BankAccountFormatType } from '../../components/internal/BankAccountFormat/types';
+import { PayoutAccountSchema } from '../../components/PayoutAccount/types';
+import { ValidatorRule } from '../../utils/validation/types';
+import { ValidationRule } from './api/get-configuration';
+import { CountryCode } from './country-code';
+import { CountryConfig } from './country-config';
+export declare const payoutFieldsMapping: Record<string, keyof PayoutAccountSchema>;
+export declare const maskedPayoutFields: Array<keyof PayoutAccountSchema>;
+export declare const countryConfig: CountryConfig;
+export declare const getValidatorRules: (validationRule: ValidationRule) => ValidatorRule<string, PayoutAccountSchema> | undefined;
+export declare const defaultPayoutAccountFormat: Partial<Record<CountryCode, BankAccountFormatType>>;

package/dist/types/core/models/scenario-fields.d.ts

@@ -0,0 +1,11 @@
+import { ValidatorRule } from '../../utils/validation/types';
+export type ScenarioFields<Schema> = Record<string, {
+    [key in keyof Schema]: ScenarioFieldSettings<Schema[key]>;
+}>;
+export interface ScenarioFieldSettings<FieldType = unknown> {
+    masked?: boolean;
+    rule?: string;
+    rules?: string[];
+    verify?: string | boolean;
+    validators?: Array<ValidatorRule<FieldType, any>>;
+}

package/dist/types/core/models/sole-prop.d.ts

@@ -0,0 +1,10 @@
+import { CountryConfig } from './country-config';
+import { ScenarioFields, ScenarioFieldSettings } from './scenario-fields';
+export declare const solePropBase: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const taxIdBase: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const fieldsPerScenario: ScenarioFields<typeof solePropBase>;
+export declare const countryConfig: CountryConfig;

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

@@ -0,0 +1,25 @@
+import { TranslationKey } from '../../language/types';
+import { TrustMemberType } from './api/trust-member-type';
+import { CountryCode } from './country-code';
+import { CountryConfig } from './country-config';
+import { ScenarioFields, ScenarioFieldSettings } from './scenario-fields';
+export declare enum TrustMemberGuidanceLabel {
+    BENEFICIARY = "beneficiary",
+    PROTECTOR = "protector",
+    TRUSTEE = "trustee",
+    SETTLOR = "settlor"
+}
+export interface TrustMemberRequirement {
+    roleTypes: readonly TrustMemberType[];
+    min: number;
+    max: number;
+    label: TrustMemberGuidanceLabel;
+}
+export declare const TRUST_COUNTRIES: CountryCode[];
+export declare const trustBase: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const fieldsPerScenario: ScenarioFields<typeof trustBase>;
+export declare const countryConfig: CountryConfig;
+export declare const DEFAULT_TRUST_MEMBER_REQUIREMENTS: readonly TrustMemberRequirement[];
+export declare const TRUST_DEFAULT_DESCRIPTIONS_MAP: Record<TrustMemberGuidanceLabel, TranslationKey>;

package/dist/types/core/process-field-configurations.d.ts

@@ -0,0 +1,66 @@
+import { PayoutAccountSchema } from '../components/PayoutAccount/types';
+import { SolePropSchema } from '../components/SoleProp/types';
+import { AnyTLDSFieldName } from '../utils/getFieldsWithExistingData';
+import { ValidatorRules } from '../utils/validation/types';
+import { BaseOuterFormProps } from './hooks/useForm';
+import { VerificationError } from './models/api/verification-error';
+import { Remediation } from './models/errors/remediation';
+import { FieldConfigurations } from './models/field-configurations';
+import { FormList } from './models/form';
+export declare function parseIndividualScenarios<FormSchema>(scenario: any, country: any): FieldConfigurations<FormSchema>;
+export declare function parseCompanyScenarios<FormSchema>(scenario: any, country: any): FieldConfigurations<FormSchema>;
+export declare function parseTrustScenarios<FormSchema>(scenario: any, country: any): FieldConfigurations<FormSchema>;
+export declare function parseSolePropScenarios(scenario: any, country: any): FieldConfigurations<SolePropSchema>;
+export declare function parsePayoutScenarios({ requiredFields, country, bankVerificationAvailable, }: {
+    requiredFields: any;
+    country: any;
+    bankVerificationAvailable: any;
+}): Partial<FieldConfigurations<PayoutAccountSchema>>;
+type PropsFromConfiguration<FormSchema> = Required<Pick<BaseOuterFormProps<FormSchema>, 'verifyFields' | 'requiredFields' | 'placeholders' | 'optionalFields' | 'labels' | 'maskedFields'>> & {
+    validators: ValidatorRules<FormSchema>;
+    allFields: {
+        [Field in keyof FormSchema]: FormSchema[Field];
+    };
+};
+/**
+ * function: getPropsFromScenarios
+ *
+ * Configurations are stored as a flat list of fields and their properties.(see identity.ts), they
+ * should be agnostic of how forms are structured and implemented. While parsing the configurations
+ * the form structure information will be used to generate props specific to the passed form.
+ * This also means the field names in configurations and forms should match.
+ *
+ * @returns value Eg:
+ * ```
+ * {
+ *     requiredFields: {
+ *         personalDetails: ['firstName', 'lastName', 'idNumber', 'residencyCountry' ],
+ *         contactDetails: ['phoneNumber', 'email']
+ *     },
+ *     optionalFields: {
+ *         contactDetails: ['email']
+ *     },
+ *     labels: {
+ *         personalDetails: {
+ *             firstName: 'givenName',
+ *             lastName: 'surName'
+ *         }
+ *     },
+ *     placeholders: {
+ *         personalDetails: {
+ *             firstName: 'givenName',
+ *         }
+ *     },
+ *     validators: {
+ *         phoneNumber: {
+ *              validate: (value, context?) => boolean;
+ *              errorMessage?: string | ErrorMessageObject;
+ *              modes: 'blur' | 'input';
+ *        }
+ *     }
+ *
+ * }
+ * ```
+ */
+export declare function getPropsFromConfigurations<FormSchema extends object>(scenarioConfiguration: FieldConfigurations<FormSchema>, forms: FormList, remediationActions: Remediation[], dataMissingErrors: VerificationError[], fieldsWithExistingData: AnyTLDSFieldName[], customRules?: {}, customLabels?: {}): PropsFromConfiguration<FormSchema>;
+export {};

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

@@ -0,0 +1,21 @@
+import { CustomTranslations } from '../language/types';
+import { CountryCode } from './models/country-code';
+export interface CoreOptions {
+    /**
+     * The URL of the KYC external API. This will be used to fetch static resources and configurations.
+     */
+    environment: string;
+    /**
+     * A public key linked to your web service user, used to fetch reference data.
+     */
+    clientKey: string;
+    /**
+     * @defaultValue 'en-US'
+     */
+    locale: string;
+    /**
+     * Custom translations and localizations
+     */
+    translations?: CustomTranslations;
+    country: CountryCode;
+}

package/dist/types/core/user-events.d.ts

@@ -0,0 +1,62 @@
+export interface UserEvent {
+    /** How many times has the event occurred */
+    count?: number;
+    /** Duration of the event */
+    dur?: number;
+    /** Sum to report with the event */
+    sum?: number;
+    /** Object with segments should be a flat object (arbitrary key/value pairs for event data) */
+    segmentation?: {
+        [key: string]: string | number | boolean | any[] | null;
+    };
+}
+interface EventQueueItem {
+    eventName: string;
+    eventPayload?: UserEvent;
+}
+export type UserEventCallback = (eventQueueItems: EventQueueItem[]) => void;
+declare class UserEvents {
+    private readonly queue;
+    private readonly subscriptions;
+    protected add(...args: any[]): void;
+    protected notifySubscribers(): void;
+    /**
+     * Adds an analytics event. Optionally can include a payload.
+     */
+    addEvent(key: string, event?: UserEvent): void;
+    /**
+     * Logs a page view event
+     * @param pageName - The name of the page/screen to log as viewed
+     */
+    addPageView(pageName: string): void;
+    /**
+     * Starts a new event which is expected to be ended with `endEvent` eventually
+     */
+    startEvent(key: string): void;
+    /**
+     * Ends an event previously started with `startEvent`. Optionally can include a payload.
+     */
+    endEvent(key: string, event?: UserEvent): void;
+    /**
+     * Subscribes a callback to analytics events. It gets called every time
+     * one of the above public methods get called, and the event data is passed back as an array.
+     * The callback must have a single argument which is an array of [eventName, eventPayload?].
+     * @example
+     * ```js
+     * const callback = ([eventName, eventPayload]) => console.log(eventName, eventPayload);
+     * this.subscribe(callback);
+     *
+     * const exampleEventPayload = { count: 1, segmentation: { foo: 'bar' } };
+     * this.addEvent('exampleEventDidOccur', exampleEventPayload);
+     *
+     * // `callback` will get called with `['exampleEventDidOccur', exampleEventPayload]`
+     * ```
+     */
+    subscribe(callback: UserEventCallback): void;
+    /**
+     * Removes a subscribed callback
+     */
+    unsubscribe(callback: UserEventCallback): void;
+}
+export declare const userEvents: UserEvents;
+export {};

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

@@ -0,0 +1,30 @@
+import { TaskTypes } from '../components/TaskList/types';
+import { LegalEntity } from './models/api/legal-entity';
+import { LegalEntityType } from './models/api/legal-entity-type';
+type BaseTrackingPayloadParams = {
+    trackingConfig?: {
+        topLevelLegalEntity: LegalEntity;
+    };
+    parentLegalEntity?: LegalEntity;
+    legalEntity?: LegalEntity;
+    task: TaskTypes;
+};
+export type BaseTrackingPayload = {
+    task: TaskTypes;
+    flow: LegalEntityType;
+    topLevelLegalEntityId: string;
+    topLevelLegalEntityType: LegalEntityType;
+    parentLegalEntityId?: string;
+    parentLegalEntityType?: LegalEntityType;
+    legalEntityId?: string;
+    legalEntityType?: LegalEntityType;
+};
+export declare function getBaseTrackingPayload({ trackingConfig, parentLegalEntity, legalEntity, task, }: BaseTrackingPayloadParams): BaseTrackingPayload;
+/**
+ * Filter data and remove unneeded fields
+ * @param dataSubmitted - actual form data submitted from the frontend
+ * @param savedLegalEntityData - the data saved in the BE
+ * @returns filtered data
+ */
+export declare const removeOldDataBySchema: (dataSubmitted: any, savedLegalEntityData: any) => any;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { Core } from './core/core';
+export default Core;

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

@@ -0,0 +1,47 @@
+import { CustomTranslations, TranslationKey, Translations } from './types';
+import { GetTranslationOptions } from './utils';
+declare class Language {
+    private supportedLocales;
+    customTranslations: CustomTranslations;
+    languageCode: string;
+    locale: string;
+    translations: Translations;
+    /**
+     * Returns a translated string from a key in the current {@link Language.locale}
+     * @param key - Translation key
+     * @param options - Translation options
+     * @returns Translated string
+     */
+    get(key: TranslationKey, options?: 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;
+    /**
+     * initialize the i18n language -- setting local, supported locales and translations
+     * @param customTranslations - translation passed to the SDK to override some keys
+     * @param locale - passed to the SDK locale or fallback
+     * @param allowedLocales - allowed locales listed from the KYC external API that we can switch to
+     *
+     */
+    initialize({ customTranslations, locale, allowedLocales, loadingContext, clientKey, }: {
+        customTranslations?: {};
+        locale?: string;
+        allowedLocales?: string[];
+        loadingContext: any;
+        clientKey: any;
+    }): Promise<void>;
+    /**
+     * Returns the translations according to the selected locale
+     * @param locale - Currently selected locale
+     * @returns Translations
+     */
+    loadTranslations({ locale, loadingContext, clientKey }: {
+        locale?: string;
+        loadingContext: any;
+        clientKey: any;
+    }): Promise<any>;
+}
+export default Language;