@adyen/kyc-components 2.2.4 → 2.2.6

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

@@ -0,0 +1,55 @@
+/**
+ * '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;
+export declare function cloneObject<T>(object: T): T;
+export declare function cloneObject<T extends unknown[]>(object: T[]): T[];
+/**
+ * @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<K extends string | number, V extends string | number>(obj: Record<K, V>): Record<V, K>;
+type ListifyOptions<ItemType> = {
+    type?: Intl.ListFormatOptions['type'];
+    style?: Intl.ListFormatOptions['style'];
+    stringify?: (item: ItemType) => string;
+};
+export declare function listify<ItemType>(array: ItemType[], { type, style, stringify, }?: ListifyOptions<ItemType>): string;
+export declare const noop: () => void;
+export {};

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

@@ -0,0 +1,8 @@
+import { LegalEntity } from '../core/models/api/legal-entity';
+import Language from '../language';
+export declare const getLegalEntityNameBasedOnType: (legalEntityResponse: LegalEntity) => string;
+/** *
+ * In payout account the account holder name is always the legal arrangement
+ * ie: trust, soleprops etc, if they exist otherwise the legal entity name is the account holder
+ */
+export declare const getPayoutAccountHolderName: (legalEntity: LegalEntity, i18n: Language) => string;

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

@@ -0,0 +1,3 @@
+import type { BaseFormProps, BaseInnerFormProps, BaseOuterFormProps } from '../core/hooks/useForm';
+export declare function getFormProps<OuterFormProps extends BaseOuterFormProps<OuterFormSchema>, NestedFormProps extends BaseFormProps<NestedFormSchema>, OuterFormSchema, NestedFormSchema>(props: OuterFormProps, innerFormId: keyof OuterFormSchema): NestedFormProps | null;
+export declare function getFieldProps<OuterFormProps extends BaseInnerFormProps<OuterFormSchema>, NestedFormProps extends BaseInnerFormProps<NestedFormSchema>, OuterFormSchema extends NestedFormSchema, NestedFormSchema>(props: OuterFormProps, innerFormFields: (keyof NestedFormSchema)[]): NestedFormProps | null;

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

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

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

@@ -0,0 +1,8 @@
+import { CompanySchema } from '../components/Company/types';
+import { IndividualSchema } from '../components/Individual/types';
+import { SolePropSchema } from '../components/SoleProp/types';
+import { TrustSchema } from '../components/Trust/types';
+import { ExistingLegalEntity } from '../core/models/api/legal-entity';
+import { RecursiveKeyOf } from './getNestedPropertyKeys';
+export type AnyTLDSFieldName = RecursiveKeyOf<IndividualSchema> | RecursiveKeyOf<CompanySchema> | RecursiveKeyOf<SolePropSchema> | RecursiveKeyOf<TrustSchema>;
+export declare const getFieldsWithExistingData: (legalEntity: ExistingLegalEntity) => AnyTLDSFieldName[];

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

@@ -0,0 +1,14 @@
+export type RecursiveKeyOf<TObj extends object> = {
+    [TKey in keyof TObj & (string | number)]: RecursiveKeyOfHandleValue<TObj[TKey], `${TKey}`>;
+}[keyof TObj & (string | number)];
+type RecursiveKeyOfInner<TObj extends object> = {
+    [TKey in keyof TObj & (string | number)]: RecursiveKeyOfHandleValue<TObj[TKey], `.${TKey}`>;
+}[keyof TObj & (string | number)];
+type RecursiveKeyOfHandleValue<TValue, Text extends string> = TValue extends any[] ? Text : TValue extends object ? `${Text}${RecursiveKeyOfInner<TValue>}` : Text;
+/**
+ * @returns A list of only the primitive keys of an object.
+ * Includes those nested within other objects, e.g. `'name.firstName'`.
+ * @param includeUndefined - whether to include properties which are defined but have a value of `undefined`.
+ */
+export declare function getNestedPropertyKeys<T extends object>(obj: T, includeUndefined?: boolean): Array<RecursiveKeyOf<T>>;
+export {};

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

@@ -0,0 +1 @@
+export declare const hasDuplicates: (arr: unknown[]) => boolean;

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

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

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

@@ -0,0 +1,15 @@
+export declare const suppressLogs: () => void;
+export interface LoggerMethods {
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
+}
+export declare const consoleMethodsPrefixable: Readonly<Array<keyof LoggerMethods>>;
+/**
+ * Creates a Logger instance
+ * @param {String} namespace - a text that should be prepended before the output
+ */
+export declare const createLogger: (namespace: string) => LoggerMethods;

package/dist/types/utils/mapping/componentApiMapping.d.ts

@@ -0,0 +1,152 @@
+import { CompanySchema } from '../../components/Company/types';
+import { IndividualSchema } from '../../components/Individual/types';
+import { SolePropSchema } from '../../components/SoleProp/types';
+import { TrustSchema } from '../../components/Trust/types';
+import { RecursiveKeyOf } from '../getNestedPropertyKeys';
+export declare const mandatoryApiFields: {
+    INDIVIDUAL: Array<Partial<RecursiveKeyOf<IndividualSchema>>>;
+    DECISIONMAKER: Array<Partial<RecursiveKeyOf<IndividualSchema>>>;
+    DECISION_MAKER_OWNER: Array<Partial<RecursiveKeyOf<IndividualSchema>>>;
+    ORGANIZATION: Array<Partial<RecursiveKeyOf<CompanySchema>>>;
+    SOLE_PROPRIETORSHIP: Array<Partial<RecursiveKeyOf<SolePropSchema>>>;
+    TRUST: Array<Partial<RecursiveKeyOf<TrustSchema>>>;
+};
+export declare const individualMaskedFields: Array<RecursiveKeyOf<IndividualSchema>>;
+export declare const individualComponentsKeyMapping: {
+    'personalDetails.residencyCountry': string;
+    'personalDetails.firstName': string;
+    'personalDetails.lastName': string;
+    'personalDetails.birthDate': string;
+    'personalDetails.idNumber': string;
+    'personalDetails.phoneNumber': string;
+    'personalDetails.email': string;
+    'personalDetails.idNumberExempt': string;
+    'personalDetails.typeOfIdentity': string;
+    'personalDetails.issuerState': string;
+    'personalDetails.licenseCardNumber': string;
+    'personalDetails.nationality': string;
+    'address.city': string;
+    'address.country': string;
+    'address.postalCode': string;
+    'address.stateOrProvince': string;
+    'address.street': string;
+    'address.houseNumberOrName': string;
+};
+export declare const individualApiKeyMapping: {
+    [x: string]: "personalDetails.firstName" | "personalDetails.lastName" | "personalDetails.issuerState" | "personalDetails.phoneNumber" | "personalDetails.email" | "personalDetails.birthDate" | "personalDetails.idNumber" | "personalDetails.licenseCardNumber" | "personalDetails.nationality" | "personalDetails.typeOfIdentity" | "personalDetails.idNumberExempt" | "address.country" | "address.street" | "address.postalCode" | "address.city" | "address.stateOrProvince" | "address.houseNumberOrName";
+};
+export declare const companyComponentsKeyMapping: {
+    'companyNameAndCountry.legalCompanyName': string;
+    'companyType.entityType': string;
+    'companyDetails.tradingName': string;
+    'companyDetails.registrationNumber': string;
+    'companyDetails.vatNumber': string;
+    'companyDetails.vatAbsenceReason': string;
+    'companyDetails.dateOfIncorporation': string;
+    'companyDetails.stockExchangeMIC': string;
+    'companyDetails.stockISIN': string;
+    'companyRegistrationDetails.registrationAddress.city': string;
+    'companyRegistrationDetails.registrationAddress.country': string;
+    'companyRegistrationDetails.registrationAddress.postalCode': string;
+    'companyRegistrationDetails.registrationAddress.stateOrProvince': string;
+    'companyRegistrationDetails.registrationAddress.street': string;
+    'companyRegistrationDetails.registrationAddress.houseNumberOrName': string;
+    'companyRegistrationDetails.operationalAddress.city': string;
+    'companyRegistrationDetails.operationalAddress.country': string;
+    'companyRegistrationDetails.operationalAddress.postalCode': string;
+    'companyRegistrationDetails.operationalAddress.stateOrProvince': string;
+    'companyRegistrationDetails.operationalAddress.street': string;
+    'companyRegistrationDetails.operationalAddress.houseNumberOrName': string;
+    'companyNameAndCountry.companyCountry': string;
+    'companyDetails.exemptedFromVat': string;
+};
+export declare const companyApiKeyMapping: {
+    [x: string]: "companyDetails.dateOfIncorporation" | "companyDetails.tradingName" | "companyDetails.stockExchangeMIC" | "companyDetails.stockISIN" | "companyDetails.vatNumber" | "companyDetails.registrationNumber" | "companyDetails.vatAbsenceReason" | "companyType.entityType" | "companyNameAndCountry.legalCompanyName" | "companyRegistrationDetails.registrationAddress.country" | "companyRegistrationDetails.registrationAddress.street" | "companyRegistrationDetails.registrationAddress.postalCode" | "companyRegistrationDetails.registrationAddress.city" | "companyRegistrationDetails.registrationAddress.stateOrProvince" | "companyRegistrationDetails.registrationAddress.houseNumberOrName" | "companyRegistrationDetails.operationalAddress.country" | "companyRegistrationDetails.operationalAddress.street" | "companyRegistrationDetails.operationalAddress.postalCode" | "companyRegistrationDetails.operationalAddress.city" | "companyRegistrationDetails.operationalAddress.stateOrProvince" | "companyRegistrationDetails.operationalAddress.houseNumberOrName";
+};
+export declare const payoutComponentKeyMapping: {
+    'payoutAccountDetails.transferInstrumentId': string;
+    'payoutAccountDetails.accountType': string;
+    'payoutAccountDetails.bankAccountNumber': string;
+    'payoutAccountDetails.swiftCode': string;
+    'payoutAccountDetails.bankCity': string;
+    'payoutAccountDetails.bankCode': string;
+    'payoutAccountDetails.bankName': string;
+    'payoutAccountDetails.branchCode': string;
+    'payoutAccountDetails.checkCode': string;
+    'payoutVerificationMethod.bankCountry': string;
+    'payoutAccountDetails.currency': string;
+    'payoutAccountDetails.iban': string;
+};
+export declare const payoutApiKeyMapping: {
+    [x: string]: "payoutAccountDetails.transferInstrumentId" | "payoutAccountDetails.accountType" | "payoutAccountDetails.bankAccountNumber" | "payoutAccountDetails.swiftCode" | "payoutAccountDetails.bankCity" | "payoutAccountDetails.bankCode" | "payoutAccountDetails.bankName" | "payoutAccountDetails.branchCode" | "payoutAccountDetails.checkCode" | "payoutVerificationMethod.bankCountry" | "payoutAccountDetails.currency" | "payoutAccountDetails.iban";
+};
+export declare const trustComponentsKeyMapping: {
+    'trustRegistrationDetails.trustType': string;
+    'trustRegistrationDetails.legalName': string;
+    'trustRegistrationDetails.country': string;
+    'trustRegistrationAddress.registrationAddress.city': string;
+    'trustRegistrationAddress.registrationAddress.country': string;
+    'trustRegistrationAddress.registrationAddress.postalCode': string;
+    'trustRegistrationAddress.registrationAddress.stateOrProvince': string;
+    'trustRegistrationAddress.registrationAddress.street': string;
+    'trustRegistrationAddress.registrationAddress.houseNumberOrName': string;
+    'trustRegistrationAddress.operationalAddress.city': string;
+    'trustRegistrationAddress.operationalAddress.country': string;
+    'trustRegistrationAddress.operationalAddress.postalCode': string;
+    'trustRegistrationAddress.operationalAddress.stateOrProvince': string;
+    'trustRegistrationAddress.operationalAddress.street': string;
+    'trustRegistrationAddress.operationalAddress.houseNumberOrName': string;
+};
+export declare const trustApiKeyMapping: {
+    [x: string]: "trustRegistrationDetails.country" | "trustRegistrationDetails.trustType" | "trustRegistrationDetails.legalName" | "trustRegistrationAddress.registrationAddress.country" | "trustRegistrationAddress.registrationAddress.street" | "trustRegistrationAddress.registrationAddress.postalCode" | "trustRegistrationAddress.registrationAddress.city" | "trustRegistrationAddress.registrationAddress.stateOrProvince" | "trustRegistrationAddress.registrationAddress.houseNumberOrName" | "trustRegistrationAddress.operationalAddress.country" | "trustRegistrationAddress.operationalAddress.street" | "trustRegistrationAddress.operationalAddress.postalCode" | "trustRegistrationAddress.operationalAddress.city" | "trustRegistrationAddress.operationalAddress.stateOrProvince" | "trustRegistrationAddress.operationalAddress.houseNumberOrName";
+};
+export declare const solePropComponentsKeyMapping: {
+    'solePropNameAndCountry.legalCompanyName': string;
+    'solePropNameAndCountry.companyCountry': string;
+    'solePropRegistrationDetails.tradingName': string;
+    'solePropRegistrationDetails.vatNumber': string;
+    'solePropRegistrationDetails.registrationNumber': string;
+    'solePropRegistrationDetails.vatAbsenceReason': string;
+    'solePropRegistrationAddress.registrationAddress.city': string;
+    'solePropRegistrationAddress.registrationAddress.country': string;
+    'solePropRegistrationAddress.registrationAddress.postalCode': string;
+    'solePropRegistrationAddress.registrationAddress.stateOrProvince': string;
+    'solePropRegistrationAddress.registrationAddress.street': string;
+    'solePropRegistrationAddress.registrationAddress.houseNumberOrName': string;
+    'solePropRegistrationAddress.operationalAddress.city': string;
+    'solePropRegistrationAddress.operationalAddress.country': string;
+    'solePropRegistrationAddress.operationalAddress.postalCode': string;
+    'solePropRegistrationAddress.operationalAddress.stateOrProvince': string;
+    'solePropRegistrationAddress.operationalAddress.street': string;
+    'solePropRegistrationAddress.operationalAddress.houseNumberOrName': string;
+    'solePropRegistrationDetails.exemptedFromVat': string;
+};
+export declare const solePropApiKeyMapping: {
+    [x: string]: "solePropNameAndCountry.companyCountry" | "solePropNameAndCountry.legalCompanyName" | "solePropRegistrationDetails.tradingName" | "solePropRegistrationDetails.vatNumber" | "solePropRegistrationDetails.registrationNumber" | "solePropRegistrationDetails.vatAbsenceReason" | "solePropRegistrationAddress.registrationAddress.country" | "solePropRegistrationAddress.registrationAddress.street" | "solePropRegistrationAddress.registrationAddress.postalCode" | "solePropRegistrationAddress.registrationAddress.city" | "solePropRegistrationAddress.registrationAddress.stateOrProvince" | "solePropRegistrationAddress.registrationAddress.houseNumberOrName" | "solePropRegistrationAddress.operationalAddress.country" | "solePropRegistrationAddress.operationalAddress.street" | "solePropRegistrationAddress.operationalAddress.postalCode" | "solePropRegistrationAddress.operationalAddress.city" | "solePropRegistrationAddress.operationalAddress.stateOrProvince" | "solePropRegistrationAddress.operationalAddress.houseNumberOrName";
+};
+/**
+ * Base api mappings do not contain document mappings as the api used for document upload is different
+ * For remediation mappings adding document mapping additionally along with the apiKeyMapping
+ */
+export declare const remediationCompanyApiKeyMapping: {
+    'organization.registeredAddress': string;
+    registrationDocument: string;
+    vatDocument: string;
+};
+export declare const remediationIndividualApiKeyMapping: {
+    'individual.residentialAddress': string;
+    'document.attachment.attachment.content': string;
+    passport: string;
+    proofOfResidency: string;
+    proofOfNationalIdNumber: string;
+};
+export declare const remediationPayoutApiKeyMapping: {
+    bankStatement: string;
+    bankAccount: string;
+};
+export declare const remediationTrustKeyMapping: {
+    constitutionalDocument: string;
+};
+export declare const remediationSolePropKeyMapping: {
+    constitutionalDocument: string;
+};

package/dist/types/utils/mapping/documentGuidanceMap.d.ts

@@ -0,0 +1,5 @@
+import { DocumentType } from '../../core/models/api/document';
+/**
+ * Returns the appropriate prefix for the document guidance image based on api documentType.
+ */
+export declare const getDocumentGuidancePrefix: (documentType: DocumentType, isIcon?: boolean, isFront?: boolean) => "passport" | "id" | "id-front" | "id-back" | "generic-document";

package/dist/types/utils/mapping/mapEntityAssociationsToUniqueTrustMembers.d.ts

@@ -0,0 +1,12 @@
+import { TaskStatus } from '../../components/TaskList/types';
+import { UniqueTrustMember } from '../../components/TrustMembers/types';
+import { LegalEntityAssociation } from '../../core/models/api/legal-entity-association';
+/**
+ * In the API response, there are multiple {@link LegalEntityAssociation}s for the same associated entity;
+ * one for each role e.g. 'trustee', 'protector', 'settlor'...
+ *
+ * Therefore we need to combine these into one {@link UniqueTrustMember} with multiple roles.
+ * @param entityAssociations
+ * @param getTaskStatusForEntityAssociation
+ */
+export declare const mapEntityAssociationsToUniqueTrustMembers: (entityAssociations: LegalEntityAssociation[], getTaskStatusForEntityAssociation: (entityAssociation: LegalEntityAssociation) => TaskStatus) => UniqueTrustMember[];

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

@@ -0,0 +1,117 @@
+import { CompanySchema } from '../../components/Company/types';
+import { IndividualSchema } from '../../components/Individual/types';
+import { PayoutBankStatementSchema } from '../../components/PayoutBankStatement/types';
+import { PayoutDetailsSchema } from '../../components/PayoutDetails/types';
+import { PersonalDetailsSchema } from '../../components/PersonalDetails/types';
+import { SolePropSchema } from '../../components/SoleProp/types';
+import { TrustSchema } from '../../components/Trust/types';
+import { Document } from '../../core/models/api/document';
+import { Individual } from '../../core/models/api/individual';
+import { LegalEntity } from '../../core/models/api/legal-entity';
+import { TransferInstrument } from '../../core/models/api/transfer-instrument';
+/**
+ * Easy to use function for mapping Individual component data to a LegalEntity
+ * @param data - an Individual person data
+ * @returns a LegalEntity ready for use with API
+ */
+export declare const mapIndividualToLegalEntity: (data: IndividualSchema) => LegalEntity;
+export declare const adjustIdentificationData: (data: PersonalDetailsSchema, apiData: Individual['identificationData']) => Individual['identificationData'];
+/**
+ * Easy to use function for mapping transferInstrument response to payout account details component data
+ * @param transferInstrument - a transferInstrument the same as found in API response
+ * @returns a Payout Details person data
+ */
+export declare const mapTransferInstrumentToPayoutAccount: (transferInstrument: TransferInstrument) => PayoutDetailsSchema;
+/**
+ * Easy to use function for mapping payout account details component data to transferInstrument
+ * @param payoutDetails - Details person data
+ * @returns transferInstrument - a transferInstrument the same as found in API response
+ */
+export declare const mapPayoutAccountToTransferInstrument: ({ data, legalEntity }: {
+    data: any;
+    legalEntity: any;
+}) => TransferInstrument;
+/**
+ * Easy to use function for mapping LegalEntity response to Individual component data
+ * @param legalEntity - a LegalEntity the same as found in API response
+ * @returns an Individual person data
+ */
+export declare const mapLegalEntityToIndividual: (legalEntity: LegalEntity, isChangingType: boolean) => IndividualSchema;
+/**
+ * Easy to use function for mapping LegalEntity response to Company component data
+ * @param legalEntity - a LegalEntity the same as found in API response
+ * @returns an Company data
+ */
+export declare const mapLegalEntityToCompany: (legalEntity: LegalEntity, isChangingType: boolean) => CompanySchema;
+/**
+ * Easy to use function for mapping Company component data to a LegalEntity
+ * @param data - an Company person data
+ * @returns a LegalEntity ready for use with API
+ */
+export declare const mapCompanyToLegalEntity: (data: CompanySchema) => LegalEntity;
+export declare const mapIndividualDocumentToApiDocument: (data: IndividualSchema, entityId: any) => Promise<Document[]>;
+export type IndividualDocumentFields = Pick<IndividualSchema, 'idDocument' | 'proofOfResidence' | 'proofOfNationalId'>;
+export declare const mapApiDocumentToIndividualDocuments: (entityId: string) => IndividualDocumentFields;
+export declare const mapCompanyDocumentToApiDocument: (data: CompanySchema, entityId: any) => Promise<Document[]>;
+export declare const mapApiDocumentToCompanyDocuments: (entityId: string) => CompanySchema;
+export declare const mapApiDocumentToPayoutDocuments: (entityId: string) => PayoutBankStatementSchema;
+export declare const mapPayoutDocumentsToApiDocuments: (data: PayoutDetailsSchema, entityId: string) => Promise<Document>;
+/**
+ * @param obj - source object
+ * @param mapping - key mappings between target and source object structure
+ * @example
+ * ```
+ *   let mapping={ 'a.b': 'x.y.z'}
+ *   let obj = {x: {y: {z: 'foo'}}}
+ *   formatObject(obj, mapping) => {a:{b:'foo'}}
+ * ```
+ */
+export declare const formatObject: (obj: any, mapping: {
+    [key: string]: string;
+}) => {};
+/**
+ * assigns the value provided to the key in targetObject.
+ * @param path - keys separated by a delimiter.
+ * @param obj - object to which value will be assigned
+ * @param val - value to be assigned
+ *
+ * @example
+ * ```
+ *   targetObject = {};
+ *   assignToProp('x.y.z', targetObject, 'foo');
+ *   console.log(targetObject); => {x:{y:{z:'foo'}}}
+ * ```
+ */
+export declare function assignToProp(path: any, obj: any, val: any): void;
+/**
+ * Easy to use function for mapping LegalEntity response to Trust component data
+ * @param legalEntity - a LegalEntity the same as found in API response
+ * @returns an Company data
+ */
+export declare const mapLegalEntityToTrust: (legalEntity: LegalEntity) => TrustSchema;
+export declare const mapTrustToLegalEntity: (data: TrustSchema) => LegalEntity;
+export declare const mapTrustDocumentToApiDocument: (data: TrustSchema, entityId: any) => Promise<Document[]>;
+/**
+ * Easy to use function for mapping LegalEntity response to SoleProprietor component data
+ * @param legalEntity - a LegalEntity the same as found in API response
+ * @returns an SoleProp data
+ */
+export declare const mapLegalEntityToSoleProp: (legalEntity: LegalEntity) => SolePropSchema;
+export declare const mapSolePropToLegalEntity: (data: SolePropSchema) => LegalEntity;
+export declare const mapSolePropDocumentToApiDocument: (data: SolePropSchema, entityId: any) => Promise<Document[]>;
+export declare const mapApiDocumentToSolePropDocuments: (entityId: string) => SolePropSchema;
+export declare const getPageName: (document: Document, pageIndex?: number) => string;
+/**
+ * returns the indicated property of an object, if it exists.
+ *
+ * @param object - The object to query
+ * @param path - The property name or path to the property
+ * @returns The value at `obj[p]`.
+
+ * @example
+ * ```
+ *   getProp({x: 100}, 'x'); //=> 100
+ *   getProp({}, 'x'); //=> undefined
+ * ```
+ */
+export declare function getProp(object: any, path: string): any;

package/dist/types/utils/payout-account-util.d.ts

@@ -0,0 +1,6 @@
+import { PayoutAccountSchema } from '../components/PayoutAccount/types';
+import { CountryCode } from '../core/models/country-code';
+import Language from '../language/Language';
+export declare const shouldShowPayoutAccountFormatSelector: (country: CountryCode) => boolean;
+export declare const shouldShowPayoutAlert: (country: CountryCode) => boolean;
+export declare const getSupportedCurrencyGuidance: (i18n: Language, country: CountryCode, requiredFields: Array<keyof PayoutAccountSchema>) => string;

package/dist/types/utils/payout-account.d.ts

@@ -0,0 +1,2 @@
+import { LegalEntity } from '../core/models/api/legal-entity';
+export declare const hasPayoutAccount: (legalEntityResponse: LegalEntity) => boolean;

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

@@ -0,0 +1,3 @@
+export type RecordWithDefault<K extends string | number | symbol, V> = Partial<Record<K, V>> & {
+    default: V;
+};

package/dist/types/utils/regex/basePatterns.d.ts

@@ -0,0 +1,3 @@
+import { RegexValidationOptions } from './types';
+export declare const emailPattern: RegExp;
+export declare const lengthValidationPatterns: Record<string, RegexValidationOptions>;

package/dist/types/utils/regex/businessRegistrationNumberPatterns.d.ts

@@ -0,0 +1,2 @@
+import type { CountryAndCompanyRegexValidation } from './types';
+export declare const businessRegistrationNumberPatterns: CountryAndCompanyRegexValidation;

package/dist/types/utils/regex/countryIdNumberPatterns.d.ts

@@ -0,0 +1,13 @@
+export declare const CountryIdNumberPatterns: {
+    BR: RegExp;
+    CA: RegExp;
+    DK: RegExp;
+    IT: RegExp;
+    PL: RegExp;
+    RO: RegExp;
+    SG: RegExp;
+    ES: RegExp;
+    SE: RegExp;
+    US: RegExp;
+    US9: RegExp;
+};

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

@@ -0,0 +1,5 @@
+export * from './basePatterns';
+export * from './businessRegistrationNumberPatterns';
+export * from './countryIdNumberPatterns';
+export * from './types';
+export * from './vatNumberPatterns';

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

@@ -0,0 +1,25 @@
+import type { CompanyTypesValue } from '../../core/models/api/company-types-value';
+import type { CountryCode } from '../../core/models/country-code';
+/**
+ * @property (regex)- The expression that will trigger the feedback message
+ * @property (format) - The translation key associated to the regex, defaults to using the string entered in this field if no translation exists
+ * @property (message) - The messagekey that will be triggered to the user
+ * @property (replaceChars) - The chars to be removed/replaced if provided
+ * @property (values) - A record of values provided for specific variable validation
+ *
+ * @example
+ * // Example use of values field
+ * { regex: /^[a-zA-Z0-9]{1,9}$/, format: 'XtoYcharacters', values: { x: 1, y: 9 } }
+ */
+export interface RegexValidationOptions {
+    regex: RegExp;
+    format?: string;
+    message?: string;
+    replaceChars?: string;
+    values?: Record<any, any>;
+}
+export type CountryRegexValidation = Partial<Record<CountryCode, RegexValidationOptions | RegexValidationOptions[]>>;
+export type CompanyTypeValidation = Partial<Record<CompanyTypesValue, RegexValidationOptions | RegexValidationOptions[]>> & {
+    default: RegexValidationOptions;
+};
+export type CountryAndCompanyRegexValidation = Partial<Record<CountryCode, CompanyTypeValidation>>;

package/dist/types/utils/regex/vatNumberPatterns.d.ts

@@ -0,0 +1,17 @@
+import type { CountryRegexValidation } from './types';
+/**
+ * Countries which follow the [countryCode][something] format
+ *
+ * @example
+ * France (FR) - FR12999999999
+ */
+export declare const vatSpecsPerCountry: CountryRegexValidation;
+/**
+ * Countries which do not follow the VAT rules ie the [countryCode][something] rule,
+ * and have their own system, or event a more complex setup
+ *
+ * @example
+ * Monaco (MC) - FR12345678912
+ * Greece (GR or EL) - EL123456789
+ */
+export declare const nonVatSpecsPerCountry: CountryRegexValidation;

package/dist/types/utils/remove-object-empty-values.d.ts

@@ -0,0 +1 @@
+export default function removeObjectPropsWithEmptyValues(obj: object): object;

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

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

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

@@ -0,0 +1,10 @@
+import { FormModel } from '../core/models/form';
+import { BaseTrackingPayload } from '../core/utils';
+import Language from '../language';
+export declare const trackNavigation: ({ fromForm, toForm, component, baseTrackingPayload, i18n, }: {
+    fromForm: FormModel;
+    toForm: FormModel;
+    component: string;
+    baseTrackingPayload: BaseTrackingPayload;
+    i18n: Language;
+}) => void;