@adyen/kyc-components 3.0.0-beta.8 → 3.0.0

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

@@ -2,4 +2,4 @@ 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";
+export declare const getDocumentGuidancePrefix: (documentType: DocumentType, isIcon?: boolean, isFront?: boolean) => "id" | "passport" | "id-front" | "id-back" | "generic-document";

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

@@ -5,10 +5,12 @@ 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 { Attachment, PageType } from '../../core/models/api/attachment';
 import { Document } from '../../core/models/api/document';
 import { Individual } from '../../core/models/api/individual';
 import { ExistingLegalEntity, LegalEntity } from '../../core/models/api/legal-entity';
 import { ExistingTransferInstrument, TransferInstrument } from '../../core/models/api/transfer-instrument';
+import { FileSchema } from '../../core/models/file';
 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
@@ -25,17 +27,19 @@ export declare const mapPayoutDetailsToTransferInstrument: ({ data, legalEntity,
     data: PayoutDetailsSchema;
     legalEntity: ExistingLegalEntity;
 }) => TransferInstrument;
-export declare const mapLegalEntityToIndividual: (legalEntity: LegalEntity, isChangingType: boolean) => IndividualSchema;
+export declare const mapLegalEntityToIndividual: (legalEntity: ExistingLegalEntity, isChangingType: boolean) => IndividualSchema;
 export declare const mapIndividualToLegalEntity: (data: IndividualSchema) => LegalEntity;
-export declare const mapLegalEntityToCompany: (legalEntity: LegalEntity, isChangingType: boolean) => CompanySchema;
+export declare const mapLegalEntityToCompany: (legalEntity: ExistingLegalEntity, isChangingType: boolean) => CompanySchema;
 export declare const mapCompanyToLegalEntity: (data: CompanySchema) => LegalEntity;
 export declare const mapLegalEntityToTrust: (legalEntity: LegalEntity) => TrustSchema;
 export declare const mapTrustToLegalEntity: (data: TrustSchema) => LegalEntity;
 export declare const mapLegalEntityToSoleProp: (legalEntity: LegalEntity) => SolePropSchema;
 export declare const mapSolePropToLegalEntity: (data: SolePropSchema) => LegalEntity;
 export type IndividualDocumentFields = Pick<IndividualSchema, 'idDocument' | 'proofOfResidence' | 'proofOfNationalId'>;
-export declare const getPageName: (document: Document, pageIndex?: number) => string;
+export declare const getPage: ({ attachments }: Document, pageType?: PageType) => Attachment;
+export declare const getPageName: (document: Document, pageType?: PageType) => string;
 export declare const mapIndividualDocumentToApiDocument: (data: IndividualSchema, entityId: string) => Promise<Document[]>;
+export declare const mapExistingFile: (name: string) => FileSchema;
 export declare const mapApiDocumentToIndividualDocuments: (entityId: string) => IndividualDocumentFields;
 export declare const mapCompanyDocumentToApiDocument: (data: CompanySchema, entityId: string) => Promise<Document[]>;
 export declare const mapApiDocumentToCompanyDocuments: (entityId: string) => CompanySchema;

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

@@ -1,3 +1,4 @@
 import { TrustMember } from '../../../components/TrustMembers/types';
 import { ExistingLegalEntity } from '../../../core/models/api/legal-entity';
 export declare const getTrustMembers: (trustLE: ExistingLegalEntity, rootLegalEntity: ExistingLegalEntity, exemptSettlorLE?: ExistingLegalEntity) => TrustMember[];
+export declare const getRootTrusteeTrustMembers: (trustLE: ExistingLegalEntity, rootLegalEntity: ExistingLegalEntity, exemptSettlorLE?: ExistingLegalEntity) => TrustMember[];

package/dist/types/utils/masking/displayValueToPureValue.d.ts

@@ -0,0 +1,10 @@
+import { Mask } from './maskTypes';
+/**
+ * Takes a formatted value and converts it back into a pure value by stripping the non-input /
+ * non-included characters in a given {@link Mask}.
+ *
+ * This is the inverse of {@link matchAgainstMask}.
+ *
+ * @see matchAgainstMask
+ */
+export declare const displayValueToPureValue: (displayValue: string, mask: Mask) => string;

package/dist/types/utils/masking/maskHelpers.d.ts

@@ -0,0 +1,6 @@
+import { InputToken, Mask, MaskToken, NonInputToken } from './maskTypes';
+export declare const nonInputs: (str: string, options?: Partial<NonInputToken>) => NonInputToken[];
+export declare const alphaInputs: (length: number, optional?: boolean) => InputToken[];
+export declare const numericInputs: (length: number, optional?: boolean) => InputToken[];
+export declare const alphanumericInputs: (length: number, optional?: boolean) => InputToken[];
+export declare const makeMask: (...tokens: MaskToken[]) => Mask;

package/dist/types/utils/masking/maskTypes.d.ts

@@ -0,0 +1,15 @@
+export interface NonInputToken {
+    type: 'nonInput';
+    char: string;
+    includeInValue: boolean;
+    displayEagerly: boolean;
+}
+export interface InputToken {
+    type: 'input';
+    allow: RegExp | undefined;
+    optional?: boolean;
+}
+export type MaskToken = NonInputToken | InputToken;
+export interface Mask {
+    tokens: MaskToken[];
+}

package/dist/types/utils/masking/masks/businessRegistrationNumberMasks.d.ts

@@ -0,0 +1,256 @@
+export declare const businessRegistrationNumberMasks: {
+    AT: {
+        firmenbuchnummer: {
+            mask: import("../maskTypes").Mask;
+        };
+        ZVR: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    AU: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            guidanceText: {
+                key: "enterNDigitsForExample";
+                values: {
+                    numDigits: string;
+                    example: string;
+                };
+            };
+        };
+    };
+    BE: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    BR: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    BG: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    CA: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    HR: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    CY: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    CZ: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    DK: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    EE: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    FI: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    FR: {
+        SIRET: {
+            mask: import("../maskTypes").Mask;
+        };
+        RNA: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    DE: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    GI: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    GR: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    GG: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    HK: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    HU: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    IE: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    IM: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    IT: {
+        codiceFiscale: {
+            mask: import("../maskTypes").Mask;
+        };
+        CCIAA: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    JE: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    LV: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    LI: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    LT: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    LU: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    MT: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    MC: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+        soleProprietorship: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    NL: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    NZ: {
+        NZBN: {
+            mask: import("../maskTypes").Mask;
+        };
+        companyNumberNZ: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    NO: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    PL: {
+        krsNumber: {
+            mask: import("../maskTypes").Mask;
+        };
+        regon: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    PT: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    RO: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    SG: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    SK: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    SI: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    ES: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    SE: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    CH: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+    GB: {
+        default: {
+            mask: import("../maskTypes").Mask;
+            transformOnType: import("../transformers/types").InputTransformer;
+        };
+    };
+    US: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
+};

package/dist/types/utils/masking/masks/vatNumberMasks.d.ts

@@ -0,0 +1,4 @@
+import { CountryCode } from '../../../core/models/country-code';
+import { Mask } from '../maskTypes';
+export type PerCountryMasks = Partial<Record<CountryCode, Mask>>;
+export declare const vatNumberMasks: PerCountryMasks;

package/dist/types/utils/masking/matchAgainstMask.d.ts

@@ -0,0 +1,28 @@
+import { Mask, MaskToken } from './maskTypes';
+interface CorrectResult {
+    outcome: 'partialCorrect' | 'correct';
+    displayValue: string;
+    potentialForMoreOptionalInput?: boolean;
+}
+export interface MismatchResult {
+    outcome: 'mismatch';
+    badChar: string;
+    mismatchAtChar: number;
+    mismatchedToken: MaskToken | 'inputTooLong';
+    partialDisplayValue: string;
+}
+export type MaskResult = CorrectResult | MismatchResult;
+/**
+ * Takes some pure value e.g. `NL123456` and a {@link Mask}, and returns a `partialCorrect`,
+ * `correct` or `mismatch` {@link MaskResult} accordingly.
+ *
+ * This is the inverse of {@link displayValueToPureValue}.
+ *
+ * @returns the result of matching the given value against the mask
+ * @param pureValue the pure, unformatted input value
+ * @param mask the mask to match against
+ *
+ * @see displayValueToPureValue
+ */
+export declare const matchAgainstMask: (pureValue: string, mask: Mask) => MaskResult;
+export {};

package/dist/types/utils/masking/transformers/types.d.ts

@@ -0,0 +1 @@
+export type InputTransformer = (str: string) => string;

package/dist/types/utils/masking/transformers/uppercase.d.ts

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

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

@@ -1,6 +1,15 @@
+import { BankAccountFormatType } from '../components/internal/BankAccountFormat/types';
+import { BankAccountNumberSchema } from '../components/internal/BankAccountNumber/types';
 import { PayoutAccountSchema } from '../components/PayoutAccount/types';
 import { CountryCode } from '../core/models/country-code';
+import { Currency } from '../core/models/currency';
 import Language from '../language/Language';
+import { FormatRules, Formatter, ValidatorRules } from './validation/types';
 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;
+export declare const getSupportedCurrenciesPerFormat: (country: CountryCode, format: BankAccountFormatType) => Currency[] | undefined;
+export declare const getBankAccountNumberFormatters: (country: CountryCode, prependFormatters: Formatter<BankAccountNumberSchema[keyof BankAccountNumberSchema]>[]) => FormatRules<BankAccountNumberSchema>;
+export type CountryBasedFormattingRules<BankAccountNumberSchema> = {
+    [country: string]: ValidatorRules<BankAccountNumberSchema>;
+};

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

@@ -0,0 +1,5 @@
+import { CountryCode } from '../core/models/country-code';
+export type PerCountry<T> = Partial<Record<CountryCode, T>>;
+export type PerCountryAndOtherDiscriminant<T, Discriminant extends string, IncludeDefault extends boolean = true> = Partial<Record<CountryCode, (IncludeDefault extends true ? {
+    default: T;
+} : object) & Partial<Record<Discriminant, T>>>>;

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

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

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

@@ -1,2 +1,160 @@
-import type { CountryAndCompanyRegexValidation } from './types';
-export declare const businessRegistrationNumberPatterns: CountryAndCompanyRegexValidation;
+export declare const businessRegistrationNumberPatterns: {
+    AU: {
+        default: RegExp;
+    };
+    AT: {
+        firmenbuchnummer: RegExp;
+        ZVR: RegExp;
+    };
+    BE: {
+        default: RegExp;
+    };
+    BR: {
+        default: RegExp;
+    };
+    BG: {
+        default: RegExp;
+    };
+    CA: {
+        default: RegExp;
+    };
+    HR: {
+        default: RegExp;
+        soleProprietorship: RegExp;
+    };
+    CY: {
+        default: RegExp;
+    };
+    CZ: {
+        default: RegExp;
+    };
+    DK: {
+        default: RegExp;
+    };
+    EE: {
+        default: RegExp;
+    };
+    FI: {
+        default: RegExp;
+    };
+    FR: {
+        SIRET: RegExp;
+        RNA: RegExp;
+    };
+    GI: {
+        default: RegExp;
+    };
+    DE: {
+        default: RegExp;
+    };
+    GR: {
+        default: RegExp;
+    };
+    GG: {
+        default: RegExp;
+    };
+    HK: {
+        default: RegExp;
+    };
+    HU: {
+        default: RegExp;
+    };
+    IS: {
+        default: RegExp;
+    };
+    IN: {
+        default: RegExp;
+    };
+    ID: {
+        default: RegExp;
+    };
+    IE: {
+        default: RegExp;
+    };
+    IM: {
+        default: RegExp;
+    };
+    IT: {
+        codiceFiscale: RegExp;
+        CCIAA: RegExp;
+    };
+    JP: {
+        default: RegExp;
+    };
+    JE: {
+        default: RegExp;
+    };
+    KR: {
+        default: RegExp;
+    };
+    LV: {
+        default: RegExp;
+    };
+    LI: {
+        default: RegExp;
+    };
+    LT: {
+        default: RegExp;
+    };
+    LU: {
+        default: RegExp;
+    };
+    MY: {
+        default: RegExp;
+    };
+    MT: {
+        default: RegExp;
+    };
+    MC: {
+        default: RegExp;
+        soleProprietorship: RegExp;
+    };
+    NL: {
+        default: RegExp;
+    };
+    NZ: {
+        NZBN: RegExp;
+        companyNumberNZ: RegExp;
+    };
+    NO: {
+        default: RegExp;
+    };
+    PL: {
+        krsNumber: RegExp;
+        regon: RegExp;
+    };
+    PT: {
+        default: RegExp;
+    };
+    PR: {
+        default: RegExp;
+    };
+    RO: {
+        default: RegExp;
+    };
+    SG: {
+        default: RegExp;
+    };
+    SK: {
+        default: RegExp;
+    };
+    SI: {
+        default: RegExp;
+    };
+    ES: {
+        default: RegExp;
+    };
+    SE: {
+        default: RegExp;
+    };
+    CH: {
+        default: RegExp;
+    };
+    GB: {
+        default: RegExp;
+        nonProfit: RegExp;
+    };
+    US: {
+        default: RegExp;
+    };
+};

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

@@ -1,3 +1,5 @@
+import { IndividualIdNumberType } from '../../components/internal/IdFieldTypeSelector/countryIdNumberTypes';
+import { PerCountryAndOtherDiscriminant } from '../perCountry';
 export declare const CountryIdNumberPatterns: {
     BR: RegExp;
     CA: RegExp;
@@ -11,3 +13,4 @@ export declare const CountryIdNumberPatterns: {
     US: RegExp;
     US9: RegExp;
 };
+export declare const customPatternsPerIdNumberType: PerCountryAndOtherDiscriminant<RegExp, IndividualIdNumberType, false>;

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

@@ -5,6 +5,4 @@ export * from './driversLicenseCardNumberPatterns';
 export * from './driversLicenseNumberPatterns';
 export * from './passportNumberPatterns';
 export * from './proofOfIdentityCardPatterns';
-export * from './trustRegistrationNumberPatterns';
-export * from './types';
 export * from './vatNumberPatterns';

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

@@ -0,0 +1,3 @@
+import { ValidatorRule } from '../validation/types';
+export declare const validateNotEmptyOnBlur: ValidatorRule<string | undefined, object>;
+export declare const validatePatternOnBlur: <ValueType extends string, FormSchema>(pattern: RegExp) => ValidatorRule<ValueType, FormSchema>;

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

@@ -1,11 +1,12 @@
-import type { CountryRegexValidation } from './types';
+import { TaxIdNumberType } from '../../components/internal/IdFieldTypeSelector/countryIdNumberTypes';
+import { PerCountry, PerCountryAndOtherDiscriminant } from '../perCountry';
 /**
  * Countries which follow the [countryCode][something] format
  *
  * @example
  * France (FR) - FR12999999999
  */
-export declare const vatSpecsPerCountry: CountryRegexValidation;
+export declare const vatSpecsPerCountry: PerCountry<RegExp>;
 /**
  * Countries which do not follow the VAT rules ie the [countryCode][something] rule,
  * and have their own system, or event a more complex setup
@@ -14,4 +15,5 @@ export declare const vatSpecsPerCountry: CountryRegexValidation;
  * Monaco (MC) - FR12345678912
  * Greece (GR or EL) - EL123456789
  */
-export declare const nonVatSpecsPerCountry: CountryRegexValidation;
+export declare const nonVatSpecsPerCountry: PerCountry<RegExp | RegExp[]>;
+export declare const customSpecsPerVatNumberType: PerCountryAndOtherDiscriminant<RegExp, TaxIdNumberType, false>;

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

@@ -1 +1 @@
-export default function removeObjectPropsWithEmptyValues(obj: object): object;
+export default function removeObjectPropsWithEmptyValues<T extends object>(obj: T): T;

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

@@ -0,0 +1,13 @@
+import { LegalEntityAssociationType } from '../core/models/api/legal-entity-association';
+import { TrustMemberGuidanceLabel } from '../core/models/trust';
+import { TranslationKey } from '../language/types';
+type Role = `${LegalEntityAssociationType | TrustMemberGuidanceLabel}`;
+type RoleMetadata<R extends Role> = Record<R, {
+    name: TranslationKey;
+    className: string;
+    description?: TranslationKey;
+}>;
+export declare const roleMetadata: Partial<RoleMetadata<Role>>;
+export declare const getRoleTagColor: (role: Role) => string;
+export declare const getRoleName: (role: Role) => TranslationKey;
+export {};

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

@@ -0,0 +1,3 @@
+type AllowedTag = 'strong' | 'a';
+export declare const sanitizeHtml: (unsafeInput: string, allowedTags?: AllowedTag[]) => string;
+export {};

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

@@ -1 +1 @@
-export declare const getScrollParent: (node: any) => any;
+export declare const getScrollParent: (node: Node | null) => HTMLElement | null;