@adyen/kyc-components 1.3.0 → 1.3.2

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

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

package/dist/types/src/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/src/core/models/errors/form-verification-errors.d.ts

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

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

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

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

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

package/dist/types/src/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/src/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/src/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/src/core/models/form-rules.d.ts

@@ -0,0 +1,12 @@
+import { TaskTypes } from '../../components/TaskList/types';
+export declare type FormRules = (data: {
+    [key: string]: any;
+}, country: string, taskType?: TaskTypes, requiredFields?: {
+    payout?: {
+        currency: string;
+        bankStatementRequirement?: 'OPTIONAL' | 'REQUIRED';
+        fields: [];
+    };
+}) => {
+    [key: string]: () => string | null | boolean;
+};

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

@@ -0,0 +1,18 @@
+import { TranslationKey } from '../../language/types';
+export interface Form {
+    formId: string;
+    formName: TranslationKey;
+    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/src/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/src/core/models/identity.d.ts

@@ -0,0 +1,41 @@
+import { ScenarioFieldSettings } from './scenario-fields';
+import { CountryConfig } from './country-config';
+import { AdditionalIdentityInfoSchema } from '../../components/IdentityAu/additionalIdentityInfoSchema';
+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/src/core/models/payout-account.d.ts

@@ -0,0 +1,7 @@
+import { CountryConfig } from './country-config';
+import { ValidatorRule } from '../../utils/Validator/types';
+import { PayoutAccountSchema } from '../../components/PayoutAccount/types';
+export declare const payoutFieldsMapping: Record<string, keyof PayoutAccountSchema>;
+export declare const maskedPayoutFields: Array<keyof PayoutAccountSchema>;
+export declare const countryConfig: CountryConfig;
+export declare const getValidatorRules: (validationName: string) => ValidatorRule<string>;

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

@@ -0,0 +1,10 @@
+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?: string | boolean;
+    validators?: ValidatorRule<FieldType>[];
+    masked?: boolean;
+}

package/dist/types/src/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/src/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/src/core/process-field-configurations.d.ts

@@ -0,0 +1,81 @@
+import { Remediation } from './models/errors/remediation';
+import FieldConfigurations from './models/field-configurations';
+import { FormList } from './models/form';
+import { SolePropSchema } from '../components/SoleProp/types';
+import { PayoutAccountSchema } from '../components/PayoutAccount/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, bankVerificationAvailable }: {
+    requiredFields: any;
+    country: any;
+    bankStatementRequirement: any;
+    bankVerificationAvailable: any;
+}): Partial<FieldConfigurations<PayoutAccountSchema>>;
+/**
+ * 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]: FormSchema[field];
+    };
+    requiredFields: {
+        [field in keyof FormSchema]: FormSchema[field];
+    };
+    validators: {
+        [field in keyof FormSchema]: FormSchema[field];
+    };
+    placeholders: {
+        [field in keyof FormSchema]: FormSchema[field];
+    };
+    optionalFields: {
+        [field in keyof FormSchema]: FormSchema[field];
+    };
+    allFields: {
+        [field in keyof FormSchema]: FormSchema[field];
+    };
+    labels: {
+        [field in keyof FormSchema]: FormSchema[field];
+    };
+    maskedFields: {
+        [field in keyof FormSchema]: FormSchema[field];
+    };
+};

package/dist/types/src/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/src/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/src/core/user-events.test.d.ts

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

package/dist/types/src/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/src/debug/progress-indicator.d.ts

@@ -0,0 +1,4 @@
+declare const webpackListener: WebSocket;
+declare let loadingElement: any;
+declare function createLoadingElement(): void;
+declare function removeLoadingElement(): void;

package/dist/types/src/index.d.ts

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

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

@@ -0,0 +1,46 @@
+import { CustomTranslations, TranslationKey } 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: TranslationKey, 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/src/language/Language.test.d.ts

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