@adyen/kyc-components 1.2.0

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

@@ -0,0 +1,14 @@
+import Address from './address';
+import { TrustTypes } from './trust-types-value';
+import { VatAbsenceReason } from './organization';
+export default interface Trust {
+    name: string;
+    doingBusinessAs: string;
+    type: TrustTypes;
+    countryOfGoverningLaw: string;
+    vatNumber: string;
+    vatAbsenceReason: VatAbsenceReason;
+    registrationNumber: string;
+    registeredAddress: Address;
+    principalPlaceOfBusiness: Address;
+}

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

@@ -0,0 +1,12 @@
+export default interface VerificationError {
+    code: string;
+    message: string;
+    type: VeriificationErrorType;
+    subErrors?: VerificationError[];
+    remediatingActions?: VerificationError[];
+}
+export declare enum VeriificationErrorType {
+    DATA_MISSING = "dataMissing",
+    INVALID_INPUT = "invalidInput",
+    PENDING_STATUS = "pendingStatus"
+}

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

@@ -0,0 +1,6 @@
+export declare enum VerificationStatus {
+    VALID = "valid",
+    PENDING = "pending",
+    INVALID = "invalid",
+    REJECTED = "rejected"
+}

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

@@ -0,0 +1,17 @@
+import { ScenarioFields, ScenarioFieldSettings } from './scenario-fields';
+import { CountryConfig } from './country-config';
+interface CompanyTypeModel {
+    id: string;
+    name: string;
+    description: string;
+}
+export declare const companyBase: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const taxIdBase: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const companyTypes: CompanyTypeModel[];
+export declare const fieldsPerScenario: ScenarioFields<typeof companyBase>;
+export declare const countryConfig: CountryConfig;
+export {};

package/dist/types/core/models/country-config.d.ts

@@ -0,0 +1,9 @@
+export declare type CountryConfig = {
+    [key: string]: {
+        [key: string]: CountryFieldConfig;
+    };
+};
+export interface CountryFieldConfig {
+    label: string;
+    placeholder?: string;
+}

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

@@ -0,0 +1,19 @@
+export declare enum Currency {
+    AUD = "AUD",
+    BGN = "BGN",
+    BRL = "BRL",
+    CAD = "CAD",
+    CHF = "CHF",
+    CZK = "CZK",
+    DKK = "DKK",
+    EUR = "EUR",
+    GBP = "GBP",
+    HUF = "HUF",
+    HRK = "HRK",
+    PLN = "PLN",
+    NOK = "NOK",
+    RON = "RON",
+    SGD = "SGD",
+    SEK = "SEK",
+    USD = "USD"
+}

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

@@ -0,0 +1,68 @@
+import { DecisionMakerType } from './api/decision-maker-type';
+/**
+ *
+ * When providing DECISION_MAKER_COUNT_RANGE configuration per country - keep in mind that you need to specify rules for each role individually even if you have a mixed rule between them.
+ *
+ * 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 declare const DEFAULT_DECISION_MAKER_COUNT_RANGE: ({
+    roleTypes: DecisionMakerType[];
+    min: number;
+    max?: undefined;
+} | {
+    roleTypes: DecisionMakerType[];
+    min: number;
+    max: number;
+})[];
+export declare const US_BR_DECISION_MAKER_COUNT_RANGE: {
+    roleTypes: DecisionMakerType[];
+    min: number;
+    max: number;
+}[];
+export declare const getDecisionMakerCountRangeConfig: (country: string) => ({
+    roleTypes: DecisionMakerType[];
+    min: number;
+    max?: undefined;
+} | {
+    roleTypes: DecisionMakerType[];
+    min: number;
+    max: number;
+})[];
+export declare const getDecisionMakerDescriptions: (country: string) => {
+    roleType: DecisionMakerType[];
+    description: string;
+}[];

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 declare type CapabilityProblems = {
+    [entityType in EntityType]: {
+        [entityId: string]: EntityProblems;
+    };
+};

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

@@ -0,0 +1,19 @@
+import { FormVerificationErrors } from './form-verification-errors';
+import { Remediation } from './remediation';
+import { TaskStatus } from '../../../components/TaskList/types';
+import VerificationError from '../api/verification-error';
+export declare type EntityProblems = {
+    verificationErrors: {
+        [formId: string]: FormVerificationErrors;
+    };
+    remediationActions: {
+        [remediationCode: string]: Remediation;
+    };
+    status: TaskStatus;
+    missingData: VerificationError[];
+    validationErrors?: {
+        [formId: string]: {
+            [fieldName: string]: any;
+        };
+    };
+};

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

@@ -0,0 +1,5 @@
+export interface ErrorMessage {
+    code: string;
+    errorMessage: string;
+    remediationMessages?: Array<string>;
+}

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

@@ -0,0 +1,4 @@
+import { ErrorMessage } from './error-message';
+export interface FieldErrors {
+    [fieldName: string]: Array<ErrorMessage>;
+}

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

@@ -0,0 +1,6 @@
+import { Remediation } from './remediation';
+export interface FormVerificationErrors {
+    [parentErrorCode: string]: {
+        [subErrorCode: string]: Remediation[];
+    };
+}

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

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

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

@@ -0,0 +1,5 @@
+export interface Remediation {
+    code: string;
+    forms: string[];
+    fields: string[];
+}

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

@@ -0,0 +1,14 @@
+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;
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { TaskTypes } from '../../components/TaskList/types';
+export declare type FormRules = (data: {
+    [key: string]: any;
+}, country: string, taskType?: TaskTypes) => {
+    [key: string]: () => string | null;
+};

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

@@ -0,0 +1,17 @@
+export interface Form {
+    formId: string;
+    formName: string;
+    fields?: Array<any>;
+    isValid?: boolean;
+    hideNavigation?: boolean;
+    hideActionBar?: boolean;
+    hasServerValidationErrors?: boolean;
+    verifyForm?(formId?: string): Promise<any>;
+    triggerValidation?(): void;
+    triggerCurrentFormValidation?(): void;
+    isCurrentFormValid?(): boolean;
+    customNavigationHandler?(): void;
+}
+export interface FormList {
+    [field: string]: Form;
+}

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

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

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

@@ -0,0 +1,33 @@
+import { ScenarioFieldSettings } from './scenario-fields';
+import { CountryConfig } from './country-config';
+export declare const identityBase: {
+    [key: string]: ScenarioFieldSettings;
+};
+export declare const identityNumber: {
+    [key: string]: 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: {
+        [x: string]: ScenarioFieldSettings<unknown>;
+    };
+    L1_IDO: {
+        [x: string]: ScenarioFieldSettings<unknown>;
+    };
+    L1_NAT: {
+        [x: string]: 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,16 @@
+import { CountryConfig } from './country-config';
+import { ValidatorRule } from '../../utils/Validator/types';
+export declare const payoutFieldsMapping: {
+    BANK_CODE: string;
+    BRANCH_CODE: string;
+    COUNTRY: string;
+    NUMBER: string;
+    BANK_CITY: string;
+    SWIFT_CODE: string;
+    IBAN: string;
+    OWNER_NAME: string;
+    BANK_NAME: string;
+    OWNER_CITY: string;
+};
+export declare const countryConfig: CountryConfig;
+export declare const getValidatorRules: (validationName: string) => ValidatorRule<string>;

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

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

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

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

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

@@ -0,0 +1,76 @@
+import { Remediation } from './models/errors/remediation';
+import FieldConfigurations from './models/field-configurations';
+import { FormList } from './models/form';
+import { SolePropSchema } from '../components/SoleProp/types';
+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, bankStatementRequirement }: {
+    requiredFields: any;
+    country: any;
+    bankStatementRequirement: any;
+}): {};
+/**
+ * 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>(scenarioConfiguration: FieldConfigurations<FormSchema>, customRules: {}, customLabels: {}, forms: FormList, remediationActions?: Remediation[]): {
+    verifyFields: {
+        [field in keyof FormSchema]: any;
+    };
+    requiredFields: {
+        [field in keyof FormSchema]: any;
+    };
+    validators: {
+        [field in keyof FormSchema]: any;
+    };
+    placeholders: {
+        [field in keyof FormSchema]: any;
+    };
+    optionalFields: {
+        [field in keyof FormSchema]: any;
+    };
+    allFields: {
+        [field in keyof FormSchema]: any;
+    };
+    labels: {
+        [field in keyof FormSchema]: any;
+    };
+};

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

@@ -0,0 +1,18 @@
+import { CustomTranslations, Locales } from '../language/types';
+export interface CoreOptions {
+    environment?: 'test' | 'live' | string;
+    /**
+     * A public key linked to your web service user, used to fetch reference data.
+     */
+    clientKey?: string;
+    /**
+     * @defaultValue 'en-US'
+     */
+    locale?: Locales | string;
+    /**
+     * Custom translations and localizations
+     */
+    translations?: CustomTranslations;
+    countryCode?: string;
+    [key: string]: any;
+}

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

@@ -0,0 +1,65 @@
+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 | Array<any> | null;
+    };
+}
+interface EventQueueItem {
+    eventName: string;
+    eventPayload?: UserEvent;
+}
+interface UserEventCallback {
+    (callbackFn: Array<EventQueueItem>): void;
+}
+declare class UserEvents {
+    private readonly queue;
+    private readonly subscriptions;
+    constructor();
+    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;
+}
+declare const _default: UserEvents;
+export default _default;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,36 @@
+import { TaskTypes } from '../components/TaskList/types';
+import LegalEntity from './models/api/legal-entity';
+import { LegalEntityType } from './models/api/legal-entity-type';
+/**
+ * Filter properties in a global configuration object from an allow list (GENERIC_OPTIONS)
+ * @param globalOptions -
+ * @returns any
+ */
+export declare function processGlobalOptions(globalOptions: any): {};
+declare type BaseTrackingPayloadParams = {
+    trackingConig?: {
+        topLevelLegalEntity: LegalEntity;
+    };
+    parentLegalEntity?: LegalEntity;
+    legalEntity?: LegalEntity;
+    task: TaskTypes;
+};
+export declare type BaseTrackingPayload = {
+    task: TaskTypes;
+    flow: LegalEntityType;
+    topLevelLegalEntityId: string;
+    topLevelLegalEntityType: LegalEntityType;
+    parentLegalEntityId?: string;
+    parentLegalEntityType?: LegalEntityType;
+    legalEntityId?: string;
+    legalEntityType?: LegalEntityType;
+};
+export declare function getBaseTrackingPayload({ trackingConig, 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 KycForms from './core/core';
+export default KycForms;

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

@@ -0,0 +1,46 @@
+import { CustomTranslations } from './types';
+declare class Language {
+    private supportedLocales;
+    customTranslations: CustomTranslations;
+    languageCode: string;
+    locale: string;
+    translations: object;
+    /**
+     * 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: string, options?: any): 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?: any[];
+        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;

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

@@ -0,0 +1 @@
+export {};