@adyen/kyc-components 1.2.0

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

@@ -0,0 +1 @@
+export { default } from './Language';

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

@@ -0,0 +1,6 @@
+export declare type Locales = string[];
+export declare type CustomTranslations = {
+    [key: string]: {
+        [message: string]: string;
+    };
+};

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

@@ -0,0 +1,53 @@
+import { CustomTranslations } from './types';
+/**
+ * Matches a string with one of the locales
+ * @param locale -
+ * @param supportedLocales -
+
+ * @example
+ * matchLocale('en-GB');
+ * // 'en-US'
+ */
+export declare function matchLocale(locale: string, supportedLocales: any): string;
+/**
+ * Returns a locale with the proper format
+ * @param localeParam -
+ *
+ * @example
+ * formatLocale('En_us');
+ * // 'en-US'
+ */
+export declare function formatLocale(localeParam: string): string;
+/**
+ * Checks the locale format.
+ * Also checks if it's on the locales array.
+ * If it is not, tries to match it with one.
+ * @param locale -
+ * @param supportedLocales -
+ */
+export declare function parseLocale(locale: string, supportedLocales?: string[]): string;
+/**
+ * Formats the locales inside the customTranslations object against the supportedLocales
+ * @param customTranslations -
+ * @param supportedLocales -
+ */
+export declare function formatCustomTranslations(customTranslations: object, supportedLocales: string[]): CustomTranslations;
+/**
+ * Returns an array with all the locales
+ * @param locale - The locale the user wants to use
+ * @param customTranslations -
+ */
+export declare const getTranslations: ({ locale, loadingContext, clientKey, customTranslations }: {
+    locale: any;
+    loadingContext: any;
+    clientKey: any;
+    customTranslations?: {};
+}) => Promise<any>;
+/**
+ * Returns an LanguageCode from local
+ * @param locale - The locale the user wants to use
+ *
+ * @example for getLanguageCode('en-US')
+ * // returns 'en'
+ */
+export declare const getLanguageCode: (locale: string) => string;

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

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

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

@@ -0,0 +1,9 @@
+import { ADDRESS_SCHEMA } from '../components/internal/Address/constants';
+export declare type AddressField = typeof ADDRESS_SCHEMA[number];
+export declare type AddressSchema = {
+    [key in AddressField]?: string;
+};
+/**
+ * Visibility options for a fieldset
+ */
+export declare type FieldsetVisibility = 'editable' | 'hidden' | 'readOnly';

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

@@ -0,0 +1,35 @@
+import { ErrorMessageObject, FieldContext, FieldData, ValidatorRules } from './types';
+export interface ValidationRuleResult {
+    isValid: boolean;
+    errorMessage: string | ErrorMessageObject;
+    hasError: boolean;
+}
+export declare type ValidationRuleResults = {
+    [key: string]: ValidationRuleResult;
+};
+declare class ValidationResult {
+    private validationResults;
+    constructor(results: ValidationRuleResult[]);
+    /** Checks if all validation rules have passed */
+    get isValid(): boolean;
+    /** Checks if any validation rule returned an error */
+    hasError(): boolean;
+    /** Returns the first validation result that returned an error */
+    getError(): ValidationRuleResult;
+    /** Returns all validation results that returned an error */
+    getAllErrors(): ValidationRuleResult[];
+}
+declare class Validator<FormSchema> {
+    rules: ValidatorRules<FormSchema>;
+    constructor(rules: ValidatorRules<FormSchema>);
+    setRules(newRules: ValidatorRules<FormSchema>): void;
+    /**
+     * Get all validation rules for a field
+     */
+    private getRulesFor;
+    /**
+     * Validates a field
+     */
+    validate<Field extends keyof FormSchema>({ key, value, mode }: FieldData<FormSchema, Field>, context?: FieldContext): ValidationResult;
+}
+export default Validator;

package/dist/types/utils/Validator/Validator.test.d.ts

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

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

@@ -0,0 +1,44 @@
+declare type ValidatorMode = 'blur' | 'input';
+export declare type ErrorMessageObject = {
+    translationKey: string;
+    translationObject: any;
+};
+export declare type Ruleset = {
+    [key: string]: any;
+};
+export declare type CountryRuleset = {
+    [country: string]: Ruleset;
+};
+export interface Format<ValueType> {
+    formatter?: (value: ValueType, context?: any) => string;
+    format?: string;
+    maxlength?: number;
+}
+export declare type FormatRules<FormSchema> = Partial<{
+    [field in keyof FormSchema]: Format<FormSchema[field]>;
+}>;
+export declare type CountryFormatRules<FormSchema> = {
+    [country: string]: FormatRules<FormSchema>;
+};
+export interface ValidatorRule<ValueType> {
+    validate: (value: ValueType, context?: any) => boolean;
+    errorMessage?: string | ErrorMessageObject;
+    modes: ValidatorMode[];
+}
+export declare type ValidatorRules<FormSchema> = Partial<{
+    [field in keyof FormSchema]: ValidatorRule<FormSchema[field]> | ValidatorRule<FormSchema[field]>[];
+}>;
+export declare type CountryBasedValidatorRules<FormSchema> = {
+    [country: string]: ValidatorRules<FormSchema>;
+};
+export interface FieldData<FormSchema, Field extends keyof FormSchema> {
+    key: Field;
+    value: FormSchema[Field];
+    mode?: ValidatorMode;
+}
+export interface FieldContext {
+    state: {
+        [key: string]: any;
+    };
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { AccountHolderTypes } from '../components/internal/AccountHolder/types';
+import { LegalEntityType } from '../core/models/api/legal-entity-type';
+export declare const accountHolderTypes: {
+    id: AccountHolderTypes;
+    name: string;
+    description: string;
+    type: LegalEntityType;
+}[];
+export declare const accountHolderTypesForOrganization: {
+    id: AccountHolderTypes;
+    name: string;
+    description: string;
+    type: LegalEntityType;
+}[];
+/**
+ ** Accountholder type value is not stored in backend as it does not effect any check evaluations.
+ ** The value is computed in the front end based on the associations and current flow of the legalEntity
+ **/
+export declare const getDefaultAccountHolderType: (legalEntityResponse: any, isTypeChanging?: boolean) => AccountHolderTypes;

package/dist/types/utils/api/documentUtils.d.ts

@@ -0,0 +1,20 @@
+import Document, { DocumentType } from '../../core/models/api/document';
+export declare type DocumentApiUtils = {
+    fetchDocuments(documentIds: Array<string>, entityId: string): Promise<Array<Document>>;
+    fetchDocument(documentId: string, entityId: string): Promise<Document>;
+    uploadDocuments(documents: Array<Document>, entityId: string): Promise<Array<Document>>;
+};
+declare const documentApiUtils: (createDocumentHandler: any, getDocumentHandler: any, updateDocumentHandler: any) => DocumentApiUtils;
+export declare const getDocument: (entityId: string, documentType: DocumentType) => Document;
+export declare const getDocuments: (entityId: string) => Array<Document>;
+export declare const getIdDocument: (entityId: string) => Document;
+export declare const createDocumentRequest: ({ entityId, entityType, documentType, page1, page2, description }: {
+    entityId: any;
+    entityType: any;
+    documentType: any;
+    page1: any;
+    page2?: any;
+    description?: any;
+}) => Promise<Document>;
+export declare const getFileExtention: (fileName: string) => string;
+export default documentApiUtils;

package/dist/types/utils/api/processCapabilitites.d.ts

@@ -0,0 +1,56 @@
+import { CapabilityProblems } from '../../core/models/errors/capability-problems';
+import LegalEntity from '../../core/models/api/legal-entity';
+import RemediationActionContext from '../../core/models/errors/remediation-action-context';
+import { Remediation } from '../../core/models/errors/remediation';
+/***
+ * Processes the capability problems and parses the problems into below form
+ * The resulting object segregates the errors based on form and fields they are mapped to
+ * and maps them to a task item. Also provides the errorCounts per entity and per form.
+ *
+ * @example
+ * ```
+ * {
+ *   BankAccount: { // Group errors based on supporting entity type
+ *       [id]: {
+ *           errors: {
+ *               [formId]: {
+ *                   [parentErrorCode]: {
+ *                       [subErrorCode]: [
+ *                           {
+ *                               { code: '1_300', forms: ['personalDetails'], fields: ['firstName', 'lastName'] }
+ *                           }
+ *                       ]
+ *                   }
+ *               },
+ *           },
+ *           remediationActions: {
+ *               '1_300': { code: '1_300', forms: ['personalDetails'], fields: ['firstName', 'lastName'] }
+ *           }
+ *       }
+ *   },
+ *   LegalEntity: {  // will contain main entity as well as associated entity Problems
+ *       [id]: {
+ *          errors: {
+ *               [formId]: {
+ *                   [parentErrorCode]: {
+ *                       [subErrorCode]: [
+ *                           {
+ *                               { code: '1_300', forms: ['personalDetails'], fields: ['firstName', 'lastName'] }
+ *                           }
+ *                       ]
+ *                   }
+ *               },
+ *           },
+ *           remediationActions: {
+ *               '1_300': { code: '1_300', forms: ['personalDetails'], fields: ['firstName', 'lastName'] }
+ *           }
+ *       }
+ *   }
+ *};
+ * ```
+ *
+ * */
+declare function getCapabilityProblems(response: LegalEntity): CapabilityProblems;
+declare const getComponentMappingFromLEFieldPath: (context: RemediationActionContext) => any;
+export declare const remediationHasFileUploadField: (remediation: Remediation) => boolean;
+export { getCapabilityProblems, getComponentMappingFromLEFieldPath };

package/dist/types/utils/api/processValidationErrors.d.ts

@@ -0,0 +1,9 @@
+import { TaskTypes } from '../../components/TaskList/types';
+import { ValidationError } from '../../core/models/errors/validation-error';
+/**
+ * Processes server validation errors received from an erroneous HTTP response.
+ * @param validationError - the validation error contain all invalid fields.
+ * @param dropinTask - the dropin page we are processing validations for.
+ */
+declare const processValidationErrors: (validationError: ValidationError, dropinTask: TaskTypes) => {};
+export default processValidationErrors;

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

@@ -0,0 +1 @@
+export default function bytesToSize(bytes: number): string;

package/dist/types/utils/company-util.d.ts

@@ -0,0 +1,6 @@
+export declare const updateTaxInformation: ({ taxId, country, exemptedFromTax, entity }: {
+    taxId: string;
+    country: string;
+    exemptedFromTax?: boolean;
+    entity: any;
+}) => any;

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

@@ -0,0 +1,15 @@
+export declare type DatasetUtil = {
+    getCountryName: (countryCode: any) => string;
+    getStateName: (stateCode: any, countryCode: any) => string;
+    getPhonePrefix: (countryCode: any) => string;
+    setDataset: (datasetKey: any, dataset: any) => void;
+    getDataset: (identifier: any) => any;
+    getDatasetKey: (identifier: any) => string;
+};
+export declare const datasetIdentifier: {
+    country: string;
+    state: (countryCode: any) => string;
+    phonePrefix: string;
+    translations: string;
+};
+export default function datasetUtilities(locale: any): DatasetUtil;

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

@@ -0,0 +1 @@
+export default function debounce<T extends Function>(cb: T, wait?: number): T;

package/dist/types/utils/decision-maker-roles.d.ts

@@ -0,0 +1,49 @@
+import { DecisionMakerType } from '../core/models/api/decision-maker-type';
+import Language from '../language/Language';
+import LegalEntity from '../core/models/api/legal-entity';
+import LegalEntityAssociation from '../core/models/api/legal-entity-association';
+import { TaskTypes } from '../components/TaskList/types';
+export declare const getTranslatedDecisionMakerRoles: (i18n: Language, allowedRoles?: DecisionMakerType[]) => ({
+    name: string;
+    description: string;
+    id: DecisionMakerType;
+    className: string;
+} | {
+    name: string;
+    description: string;
+    id: DecisionMakerType;
+    className: string;
+} | {
+    name: string;
+    description: string;
+    id: DecisionMakerType;
+    className: string;
+})[];
+export declare const getDecisionMakerTagColor: (decisionMakerType: DecisionMakerType) => string;
+export declare const getDecisionMakerName: (decisionMakerType: DecisionMakerType) => string;
+export declare const getOwnDecisionMakers: (legalEntity: LegalEntity) => Array<LegalEntityAssociation>;
+export declare const getOwnSignatories: (legalEntity: LegalEntity) => LegalEntityAssociation[];
+export declare const getOwnDecisionMakersLegalEntityIds: (legalEntity: LegalEntity) => string[];
+export declare const getDecisionMakerCount: (legalEntityResponse: LegalEntity) => {};
+export declare const getAllowedDecisionMakerRoles: (legalEntityResponse: LegalEntity, taskType: TaskTypes) => DecisionMakerType[];
+export declare const hasMinRequiredDecisionMakerCount: (legalEntityResponse: LegalEntity) => boolean;
+export declare const decisionMakerRoles: {
+    uboThroughControl: {
+        id: DecisionMakerType;
+        name: string;
+        description: string;
+        className: string;
+    };
+    uboThroughOwnership: {
+        id: DecisionMakerType;
+        name: string;
+        description: string;
+        className: string;
+    };
+    signatory: {
+        id: DecisionMakerType;
+        name: string;
+        description: string;
+        className: string;
+    };
+};

package/dist/types/utils/decision-maker-roles.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @jest-environment jsdom
+ */
+export {};

package/dist/types/utils/entity-association-util.d.ts

@@ -0,0 +1,91 @@
+import LegalEntityAssociation from '../core/models/api/legal-entity-association';
+import Language from '../language';
+import LegalEntity from '../core/models/api/legal-entity';
+import { CapabilityProblems } from '../core/models/errors/capability-problems';
+import { EntityProblems } from '../core/models/errors/entity-problems';
+export declare const entityAssociationRoles: {
+    uboThroughControl: {
+        id: import("../core/models/api/decision-maker-type").DecisionMakerType;
+        name: string;
+        description: string;
+        className: string;
+    };
+    uboThroughOwnership: {
+        id: import("../core/models/api/decision-maker-type").DecisionMakerType;
+        name: string;
+        description: string;
+        className: string;
+    };
+    signatory: {
+        id: import("../core/models/api/decision-maker-type").DecisionMakerType;
+        name: string;
+        description: string;
+        className: string;
+    };
+    definedBeneficiary: {
+        id: import("../core/models/api/trust-member-type").TrustMemberType;
+        name: string;
+        description: string;
+        className: string;
+    };
+    protector: {
+        id: import("../core/models/api/trust-member-type").TrustMemberType;
+        name: string;
+        description: string;
+        className: string;
+    };
+    secondaryTrustee: {
+        id: import("../core/models/api/trust-member-type").TrustMemberType;
+        name: string;
+        description: string;
+        className: string;
+    };
+    settlor: {
+        id: import("../core/models/api/trust-member-type").TrustMemberType;
+        name: string;
+        description: string;
+        className: string;
+    };
+};
+export declare const getEntityAssociationTagColor: (entityAssociationType: LegalEntityAssociation['type']) => any;
+export declare const getEntityAssociationName: (entityAssociationType: LegalEntityAssociation['type']) => any;
+export declare const getTranslatedEntityAssociationRoles: (i18n: Language, allowedRoles?: LegalEntityAssociation['type']) => ({
+    name: string;
+    description: string;
+    id: import("../core/models/api/trust-member-type").TrustMemberType;
+    className: string;
+} | {
+    name: string;
+    description: string;
+    id: import("../core/models/api/trust-member-type").TrustMemberType;
+    className: string;
+} | {
+    name: string;
+    description: string;
+    id: import("../core/models/api/trust-member-type").TrustMemberType;
+    className: string;
+} | {
+    name: string;
+    description: string;
+    id: import("../core/models/api/trust-member-type").TrustMemberType;
+    className: string;
+} | {
+    name: string;
+    description: string;
+    id: import("../core/models/api/decision-maker-type").DecisionMakerType;
+    className: string;
+} | {
+    name: string;
+    description: string;
+    id: import("../core/models/api/decision-maker-type").DecisionMakerType;
+    className: string;
+} | {
+    name: string;
+    description: string;
+    id: import("../core/models/api/decision-maker-type").DecisionMakerType;
+    className: string;
+})[];
+export declare const getOwnEntityAssociations: (legalEntity: LegalEntity) => Array<LegalEntityAssociation>;
+export declare const getOwnSoleProprietorshipIdArray: (legalEntity: LegalEntity) => Array<string>;
+export declare const hasSolePropInLegalEntity: (legalEntity: LegalEntity) => boolean;
+export declare const getOwnSolePropProblems: (legalEntity: LegalEntity, capabilityProblems: CapabilityProblems) => EntityProblems;

package/dist/types/utils/entity-association-util.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @jest-environment jsdom
+ */
+export {};

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

@@ -0,0 +1,9 @@
+export declare const downloadFile: (base64: any, filename: any) => Promise<void>;
+export declare const base64ToBlob: (base64: any, mimeType?: string) => Blob;
+/**
+ * Utility to save Blob|File reference to disk as a new file
+ *
+ * @param fileData -
+ * @param filename -
+ */
+export declare const saveBlobAsFile: (fileData: any, filename: any) => void;

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

@@ -0,0 +1,15 @@
+export declare type FormUtils = {
+    getPlaceholder: (field: any, fallbackPlaceholderKey?: any) => string;
+    getLabel: (field: any, fallbackLabelKey?: any) => string;
+    isRequiredField: (field: any, showIfNotInRequiredFields?: any) => boolean;
+    isOptionalField: (field: any) => boolean;
+    isVisibleField: (field: any, showIfNotInRequiredFields?: any) => boolean;
+    isReadOnly: (field: any) => boolean;
+    getVal: (val: getValProps) => string;
+    getErrorMessage: (field: any, errors: any, fieldProblems: any) => string | boolean;
+};
+export declare type getValProps = string | {
+    translationKey: string;
+    translationObject: object;
+};
+export default function formUtilities(props: any, i18n?: any): FormUtils;

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

@@ -0,0 +1,61 @@
+/**
+ * 'Destructures' properties from object - returns a new object only containing those properties that were asked for (including if those properties
+ * have values that are falsy: null, undefined, false, '').
+ *
+ * @param args - property names to select: can be either 'regular' arguments (comma separated list) or an array
+ * @returns - an object with a function 'from' that accepts a single argument - the object from which to choose properties.
+ * This function returns a new object - a copy of the original but only including the desired properties
+ *
+ * @example const strippedObj = pick('cardType', 'securityCode').from(cardObject);
+ * @example const strippedObj = pick(['cardType', 'securityCode']).from(cardObject);
+ */
+export declare function pick(...args: any[]): {
+    from: (obj: any) => any;
+};
+/**
+ *'Destructures' properties from object, returning a new object containing all the original objects properties except those that were specifically rejected
+ *
+ * @param args - property names to reject: can be either 'regular' arguments (comma separated list) or an array
+ * @returns - an object with a function 'from' that accepts a single argument - the object from which to reject properties.
+ * This function returns a new object - a copy of the original but excluding the selected properties
+ *
+ * @example const strippedObj = drop('permittedLengths', 'pattern', 'startingRules').from(cardObject);
+ * @example const strippedObj = drop(['permittedLengths', 'pattern', 'startingRules']).from(cardObject);
+ */
+export declare function drop(...args: any[]): {
+    from: (obj: any) => any;
+};
+/**
+ * Compares 2 arrays of (primitive) values to see if they are the same
+ * re. https://sebhastian.com/javascript-compare-array/
+ */
+export declare function doArraysMatch(arr1: any, arr2: any): any;
+/**
+ * Recursively compare 2 objects
+ */
+export declare const objectsDeepEqual: (x: any, y: any) => any;
+/**
+ * returns the clone of an object.
+ * Only supports simple data types and does not look for circular references
+ * A complete implementation of deepclone would be an overkill currently.
+ * @param object - object to be cloned
+ * @returns cloned object.
+ */
+export declare function cloneObject(object: any): any;
+/**
+ * @param obj - object to reverse
+ * @example
+ * ```
+ *   let obj = {a:1,b:2,c:3};
+ *   reverseObject(obj); => {1:'a', 2: 'b', 3: 'c'}
+ * ```
+ */
+export declare function reverseObject(obj: any): any;
+declare type ListifyOptions<ItemType> = {
+    type?: Intl.ListFormatOptions['type'];
+    style?: Intl.ListFormatOptions['style'];
+    stringify?: (item: ItemType) => string;
+};
+export declare function listify<ItemType>(array: Array<ItemType>, { type, style, stringify }?: ListifyOptions<ItemType>): string;
+export declare const noop: () => void;
+export {};

package/dist/types/utils/genUtils.test.d.ts

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

package/dist/types/utils/get-image.d.ts

@@ -0,0 +1,11 @@
+export interface ImageOptions {
+    extension?: string;
+    path?: string;
+    loadingContext?: string;
+    name?: string;
+    size?: string;
+    svgOptions?: string;
+    type?: string;
+}
+export declare const getImageUrl: ({ loadingContext, extension, size, ...options }: ImageOptions) => Function;
+export default getImageUrl;

package/dist/types/utils/get-image.test.d.ts

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

package/dist/types/utils/get-name.d.ts

@@ -0,0 +1 @@
+export declare const getLegalEntityNameBasedOnType: (legalEntityResponse: any) => any;

package/dist/types/utils/get-props.d.ts

@@ -0,0 +1,4 @@
+import { BaseFormProps, BaseInnerFormProps, BaseOuterFormProps } from './useForm/types';
+declare function getFormProps<OuterFormProps extends BaseOuterFormProps<OuterFormSchema>, NestedFormProps extends BaseFormProps<NestedFormSchema>, OuterFormSchema, NestedFormSchema>(props: OuterFormProps, innerFormId: any): NestedFormProps;
+declare function getFieldProps<OuterFormProps extends BaseInnerFormProps<OuterFormSchema>, NestedFormProps extends BaseInnerFormProps<NestedFormSchema>, OuterFormSchema extends NestedFormSchema, NestedFormSchema>(props: OuterFormProps, innerFormFields: any): NestedFormProps;
+export { getFieldProps, getFormProps };

package/dist/types/utils/get-task-status.d.ts

@@ -0,0 +1,9 @@
+import { EntityType } from '../core/models/api/entity-type';
+import { TaskStatus } from '../components/TaskList/types';
+import { CapabilityProblems } from '../core/models/errors/capability-problems';
+import LegalEntity from '../core/models/api/legal-entity';
+declare const getTaskStatus: (type: EntityType, capabilityProblems: CapabilityProblems, legalEntity: LegalEntity, entityIds?: string[]) => TaskStatus;
+export declare const hasPendingCapabilities: (legalEntityResponse: LegalEntity) => boolean;
+export declare const hasResolvedCapabilities: (legalEntityResponse: LegalEntity) => boolean;
+export declare const isEmptyEntity: (legalEntityResponse: LegalEntity) => boolean;
+export default getTaskStatus;

package/dist/types/utils/get-task-status.test.d.ts

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

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

@@ -0,0 +1 @@
+export declare const getUniqueId: (prefix?: string) => string;