@adyen/kyc-components 2.48.1 → 2.49.0

package/dist/types/components/BasicInformation/component/BasicInformationComponent.d.ts

@@ -3,4 +3,4 @@ import type { BusinessDetailsSchema } from '../../BusinessDetails/types';
 import type { BasicInformationProps, BasicInformationSchema } from '../types';
 export declare const BASIC_INFORMATION_FORM_ID: keyof BusinessDetailsSchema;
 export declare const basicInformationFields: Array<keyof BasicInformationSchema>;
-export declare function BasicInformationComponent({ data, labels, placeholders, helperText, heading, description, readOnly, shouldValidate, formVerificationErrors, fieldValidationErrors, allFields, requiredFields, obscuredFields, optionalFields, readOnlyFields, trustedFields, country, companyType, isTopLevelEntity, isBusinessSelection, }: BasicInformationProps): import("preact").JSX.Element;
+export declare function BasicInformationComponent({ data, labels, placeholders, helperText, heading, description, readOnly, shouldValidate, formVerificationErrors, fieldValidationErrors, allFields, requiredFields, obscuredFields, optionalFields, readOnlyFields, trustedFields, country, companyType, isTopLevelEntity, isBusinessSelection, setVerifiedBusiness, searchName, }: BasicInformationProps): import("preact").JSX.Element;

package/dist/types/components/BasicInformation/types.d.ts

@@ -1,4 +1,6 @@
+import type { Dispatch, StateUpdater } from 'preact/hooks';
 import type { BaseInnerFormProps } from '../../core/hooks/useForm';
+import type { CompanyDatasetResponse } from '../../core/models/api/company-search';
 import type { CompanyTypesValue } from '../../core/models/api/company-types-value';
 import type { CountryCode } from '../../core/models/country-code';
 import type { BaseTrackingPayload } from '../../core/utils';
@@ -14,4 +16,6 @@ export interface BasicInformationProps extends BaseInnerFormProps<BasicInformati
     isTopLevelEntity: boolean;
     baseTrackingPayload: BaseTrackingPayload;
     isBusinessSelection: boolean;
+    setVerifiedBusiness: Dispatch<StateUpdater<CompanyDatasetResponse | undefined>>;
+    searchName: string | undefined;
 }

package/dist/types/components/Dropins/HighExposureDropin/components/AdditionalFieldsForHighExposureParentCompany.d.ts

@@ -1,4 +1,5 @@
-import type { HighExposureParentCompanyDetailsProps, HighExposureParentCompanySchema } from '../types';
+import type { FieldMapping, HighExposureParentCompanyDetailsProps, HighExposureParentCompanySchema } from '../types';
+export declare const parentCompanyFieldMapping: FieldMapping;
 export declare const highExposureParentCompanyDetailsFields: Array<keyof HighExposureParentCompanySchema>;
 declare function AdditionalFieldsForHighExposureParentCompany(props: HighExposureParentCompanyDetailsProps): import("preact").JSX.Element;
 export default AdditionalFieldsForHighExposureParentCompany;

package/dist/types/components/Dropins/HighExposureDropin/components/AmountSelector/AmountSelector.d.ts

@@ -0,0 +1,2 @@
+import type { AmountSelectorProps } from './types';
+export default function AmountSelector({ currency, value, validCurrency, validValue, handleChangeForCurrency, handleChangeForValue, country, fieldName, fieldLabel, fieldHelper, errorMessage, ariaLabelCurrency, ariaLabelValue, }: AmountSelectorProps): import("preact").JSX.Element;

package/dist/types/components/Dropins/HighExposureDropin/components/AmountSelector/types.d.ts

@@ -0,0 +1,16 @@
+import type { CountryCode } from '../../../../../core/models/country-code';
+export type AmountSelectorProps = {
+    country: CountryCode;
+    handleChangeForCurrency: (e: any) => void;
+    handleChangeForValue: (e: any) => void;
+    fieldName: string;
+    fieldLabel?: string;
+    fieldHelper?: string;
+    errorMessage?: string | boolean;
+    currency?: string;
+    value?: number;
+    validCurrency?: any;
+    validValue?: any;
+    ariaLabelCurrency: string;
+    ariaLabelValue: string;
+};

package/dist/types/components/Dropins/HighExposureDropin/components/HighExposureDropinComponent.d.ts

@@ -1,5 +1,6 @@
 import type { FormList } from '../../../../core/models/form';
 import type { HighExposureDropinProps } from '../types';
 export declare const highExposureForms: FormList;
+export declare const highExposureFormsRequiredFields: Record<string, string[]>;
 declare function HighExposureDropinComponent(props: HighExposureDropinProps): import("preact").JSX.Element;
 export default HighExposureDropinComponent;

package/dist/types/components/Dropins/HighExposureDropin/components/HighExposureFinancialInformation.d.ts

@@ -0,0 +1,3 @@
+import type { HighExposureFinancialInformationProps } from '../types';
+declare function HighExposureFinancialInformation({ formUtils, data, valid, errors, fieldProblems, handleChangeFor, country, fieldMapping, sectionHeading, }: HighExposureFinancialInformationProps): import("preact").JSX.Element;
+export default HighExposureFinancialInformation;

package/dist/types/components/Dropins/HighExposureDropin/components/HighExposureLegalInformation.d.ts

@@ -0,0 +1,3 @@
+import type { HighExposureLegalInformationProps } from '../types';
+declare function HighExposureLegalInformation({ formUtils, data, valid, errors, fieldProblems, handleChangeFor, fieldMapping, sectionHeading, }: HighExposureLegalInformationProps): import("preact").JSX.Element;
+export default HighExposureLegalInformation;

package/dist/types/components/Dropins/HighExposureDropin/components/HighExposureRegisteredAddress.d.ts

@@ -0,0 +1,4 @@
+import './styles.scss';
+import { type HighExposureRegisteredAddressProps } from '../types';
+declare function HighExposureRegisteredAddress({ formUtils, data, valid, errors, fieldProblems, handleChangeFor, legalEntity, fieldMapping, sectionHeading, country, legalEntityId, handleAddressSearch, handleFindAddress, targetPage, }: HighExposureRegisteredAddressProps): import("preact").JSX.Element;
+export default HighExposureRegisteredAddress;

package/dist/types/components/Dropins/HighExposureDropin/defaultCurrencies.d.ts

@@ -0,0 +1,3 @@
+import type { CountryCode } from '../../../core/models/country-code';
+import type { HighExposureCompanySchema } from './types';
+export declare const setDefaultCurrencies: (dataObject: HighExposureCompanySchema, country: CountryCode) => void;

package/dist/types/components/Dropins/HighExposureDropin/types.d.ts

@@ -6,7 +6,7 @@ import type { FormModel } from '../../../core/models/form';
 import type { Translatable, TranslationKey } from '../../../language/types';
 import type { FormUtils } from '../../../utils/formUtils';
 import type { ValidationRuleResult, ValidatorMode } from '../../../utils/validation/types';
-import type { DropinProps } from '../types';
+import type { DropinAPIHandlers, DropinProps } from '../types';
 export interface HighExposureCompanySchema {
     country?: CountryCode;
     numberOfEmployees?: number;
@@ -17,6 +17,12 @@ export interface HighExposureCompanySchema {
     legalEntityIdentifier?: string;
     isCompanyOwnedByAnotherCompany?: string;
     isParentOwnedByAnotherCompany?: string;
+    totalAssetsValue?: number;
+    totalAssetsCurrency?: string;
+    annualTurnoverValue?: number;
+    annualTurnoverCurrency?: string;
+    financialReportingDate?: string;
+    legalInformationInsolvency?: string;
 }
 export type HighExposureParentCompanySchema = {
     country?: CountryCode;
@@ -28,6 +34,19 @@ export type HighExposureParentCompanySchema = {
     doesYourParentCompanyHaveLEI?: string;
     parentLegalEntityIdentifier?: string;
     doesNotKnowParentNumberOfEmployees?: boolean;
+    isParentCompanyAddressTheMainHeadquarters?: string;
+    parentCompanyAddress?: string;
+    parentCompanyOtherAddressInformation?: string;
+    parentCompanyPostalCode?: string;
+    parentCompanyCity?: string;
+    parentCompanyStateOrProvince?: string;
+    parentCompanyCountry?: string;
+    totalAssetsValue?: number;
+    totalAssetsCurrency?: string;
+    annualTurnoverValue?: number;
+    annualTurnoverCurrency?: string;
+    financialReportingDate?: string;
+    legalInformationInsolvency?: string;
 };
 export type HighExposureUltimateParentCompanySchema = {
     country?: CountryCode;
@@ -39,6 +58,19 @@ export type HighExposureUltimateParentCompanySchema = {
     doesYourUltimateParentCompanyHaveLEI?: string;
     ultimateParentLegalEntityIdentifier?: string;
     doesNotKnowUltimateParentNumberOfEmployees?: boolean;
+    isUltimateParentCompanyAddressTheMainHeadquarters?: string;
+    ultimateParentCompanyAddress?: string;
+    ultimateParentCompanyOtherAddressInformation?: string;
+    ultimateParentCompanyPostalCode?: string;
+    ultimateParentCompanyCity?: string;
+    ultimateParentCompanyStateOrProvince?: string;
+    ultimateParentCompanyCountry?: string;
+    totalAssetsValue?: number;
+    totalAssetsCurrency?: string;
+    annualTurnoverValue?: number;
+    annualTurnoverCurrency?: string;
+    financialReportingDate?: string;
+    legalInformationInsolvency?: string;
 };
 export interface HighExposureSchema {
     company?: HighExposureCompanySchema;
@@ -52,6 +84,8 @@ export interface HighExposureDropinProps extends BaseOuterFormProps<HighExposure
     country: CountryCode;
     legalEntityId: ExistingLegalEntity['id'];
     legalEntity?: ExistingLegalEntity;
+    handleAddressSearch?: DropinAPIHandlers['handleAddressSearch'];
+    handleFindAddress?: DropinAPIHandlers['handleFindAddress'];
 }
 export interface HighExposureProps extends HighExposureDropinProps, DropinProps {
     legalEntityId: ExistingLegalEntity['id'];
@@ -68,19 +102,23 @@ export interface HighExposureParentCompanyDetailsProps extends BaseInnerFormProp
     country: CountryCode;
     legalEntityId: string;
     legalEntity?: ExistingLegalEntity;
+    handleAddressSearch: DropinAPIHandlers['handleAddressSearch'];
+    handleFindAddress: DropinAPIHandlers['handleFindAddress'];
 }
 export interface HighExposureUltimateParentCompanyDetailsProps extends BaseInnerFormProps<HighExposureUltimateParentCompanySchema> {
     country: CountryCode;
     legalEntityId: string;
     legalEntity?: ExistingLegalEntity;
+    handleAddressSearch: DropinAPIHandlers['handleAddressSearch'];
+    handleFindAddress: DropinAPIHandlers['handleFindAddress'];
 }
 export type HighExposureSchemaCombined = HighExposureCompanySchema & HighExposureParentCompanySchema & HighExposureUltimateParentCompanySchema;
 export declare enum HighExposurePagesEnums {
-    COMPANY_PAGE = "COMPANY_PAGE",
-    PARENT_COMPANY_PAGE = "PARENT_COMPANY_PAGE",
-    ULTIMATE_PARENT_COMPANY_PAGE = "ULTIMATE_PARENT_COMPANY_PAGE"
+    COMPANY_PAGE = "company",
+    PARENT_COMPANY_PAGE = "parentCompany",
+    ULTIMATE_PARENT_COMPANY_PAGE = "ultimateParentCompany"
 }
-type HighExposureSchemaKeys = keyof HighExposureCompanySchema | keyof HighExposureParentCompanySchema | keyof HighExposureUltimateParentCompanySchema;
+export type HighExposureSchemaKeys = keyof HighExposureCompanySchema | keyof HighExposureParentCompanySchema | keyof HighExposureUltimateParentCompanySchema;
 export type HighExposureBusinessInformationProps = {
     country: CountryCode;
     data: Partial<HighExposureSchemaCombined>;
@@ -106,6 +144,29 @@ export interface HighExposureOwnershipStructureProps extends BaseInnerFormProps<
     handleChangeFor: (key: keyof HighExposureCompanySchema, mode?: ValidatorMode) => (e: any) => void;
     legalEntity?: LegalEntity;
 }
+export type HighExposureFinancialInformationProps = {
+    country: CountryCode;
+    data: Partial<HighExposureSchemaCombined>;
+    valid: Partial<Record<keyof HighExposureSchemaCombined, boolean>>;
+    errors: Partial<Record<keyof HighExposureSchemaCombined, ValidationRuleResult | null>>;
+    fieldProblems: Partial<Record<keyof HighExposureSchemaCombined, boolean>>;
+    handleChangeFor: (key: keyof HighExposureSchemaCombined, mode?: ValidatorMode) => (e: any) => void;
+    formUtils: FormUtils<HighExposureSchemaCombined>;
+    targetPage: HighExposurePagesEnums;
+    fieldMapping: FieldMapping;
+    sectionHeading?: Translatable;
+};
+export type HighExposureLegalInformationProps = {
+    data: Partial<HighExposureSchemaCombined>;
+    valid: Partial<Record<keyof HighExposureSchemaCombined, boolean>>;
+    errors: Partial<Record<keyof HighExposureSchemaCombined, ValidationRuleResult | null>>;
+    fieldProblems: Partial<Record<keyof HighExposureSchemaCombined, boolean>>;
+    handleChangeFor: (key: keyof HighExposureSchemaCombined, mode?: ValidatorMode) => (e: any) => void;
+    formUtils: FormUtils<HighExposureSchemaCombined>;
+    targetPage: HighExposurePagesEnums;
+    fieldMapping: FieldMapping;
+    sectionHeading?: Translatable;
+};
 export declare enum HighExposureRadioIds {
     YES = "Yes",
     NO = "No",
@@ -119,4 +180,19 @@ export declare const highExposureParentRadioItems: Array<{
     id: HighExposureRadioIds;
     name: TranslationKey;
 }>;
-export {};
+export type HighExposureRegisteredAddressProps = {
+    country: CountryCode;
+    data: Partial<HighExposureSchemaCombined>;
+    valid: Partial<Record<keyof HighExposureSchemaCombined, boolean>>;
+    formUtils: FormUtils<HighExposureSchemaCombined>;
+    errors: Partial<Record<keyof HighExposureSchemaCombined, ValidationRuleResult | null>>;
+    fieldProblems: Partial<Record<keyof HighExposureSchemaCombined, boolean>>;
+    handleChangeFor: (key: keyof HighExposureSchemaCombined, mode?: ValidatorMode) => (e: any) => void;
+    legalEntity?: LegalEntity;
+    targetPage: HighExposurePagesEnums;
+    fieldMapping: FieldMapping;
+    sectionHeading?: Translatable;
+    legalEntityId: string;
+    handleAddressSearch: DropinAPIHandlers['handleAddressSearch'];
+    handleFindAddress: DropinAPIHandlers['handleFindAddress'];
+};

package/dist/types/components/Individual/types.d.ts

@@ -23,6 +23,7 @@ export interface IndividualSchema {
     idDocument?: IdDocumentUploadSchema;
     proofOfResidence?: DocumentUploadSchema;
     proofOfNationalId?: DocumentUploadSchema;
+    proofOfRelationship?: DocumentUploadSchema;
     idVerificationMethod?: IdVerificationMethodSchema;
 }
 export interface IndividualProps extends BaseOuterFormProps<IndividualSchema> {
@@ -35,6 +36,7 @@ export interface IndividualProps extends BaseOuterFormProps<IndividualSchema> {
     legalEntityId?: string;
     taskType?: TaskTypes;
     allowedRoles?: DecisionMakerType[];
+    parentLegalEntity?: ExistingLegalEntity;
     onTypeSwitch?(legalEntityType: LegalEntityType): void;
     onCountryChange?: Dispatch<StateUpdater<CountryCode>>;
     onNext?(e: any, callbacks: any, isValid: any): void;
@@ -43,7 +45,6 @@ export interface IndividualProps extends BaseOuterFormProps<IndividualSchema> {
     accountHolder: AccountHolderOption | null;
 }
 export interface IndividualDropinProps extends Omit<IndividualProps, 'legalEntityId' | 'accountHolder'>, IndividualDropinApiHandlers, DropinProps {
-    parentLegalEntity?: ExistingLegalEntity;
     trustMember?: TrustMember;
     isTargetLegalEntityType?: boolean;
     country: CountryCode;

package/dist/types/components/Individual/validators.d.ts

@@ -2,11 +2,14 @@ import type { ExperimentName } from '../../core/Context/ExperimentContext/types'
 import type { CountryCode } from '../../core/models/country-code';
 import type { ValidatorRule } from '../../utils/validation/types';
 import type { PersonalDetailsSchema } from '../PersonalDetails/types';
-export declare const validators: ({ country, isExperimentEnabled, }: {
+import { TaskTypes } from '../TaskList/types';
+export declare const validators: ({ country, isExperimentEnabled, taskType, }: {
     country: CountryCode;
     isExperimentEnabled?: (experiment: ExperimentName) => boolean;
+    taskType?: TaskTypes;
 }) => {
     birthDate: () => ValidatorRule<string, PersonalDetailsSchema>[];
     nationality: () => ValidatorRule<PersonalDetailsSchema["nationality"], PersonalDetailsSchema>;
     jobTitle: () => ValidatorRule<PersonalDetailsSchema["jobTitle"], PersonalDetailsSchema>;
+    relationship: () => ValidatorRule<PersonalDetailsSchema["relationship"], PersonalDetailsSchema>;
 };

package/dist/types/components/PersonalDetails/component/PersonalDetailsComponent.d.ts

@@ -1,3 +1,9 @@
+import type { LegalRepresentativeRelationshipType } from '../../../core/models/api/legal-entity-association';
+import type { TranslationKey } from '../../../language/types';
 import type { PersonalDetailsProps, PersonalDetailsSchema } from '../types';
 export declare const personalDetailsFields: Array<keyof PersonalDetailsSchema>;
+export declare const relationshipOptions: Array<{
+    id: LegalRepresentativeRelationshipType;
+    name: TranslationKey;
+}>;
 export declare function PersonalDetailsComponent(props: PersonalDetailsProps): import("preact").JSX.Element;

package/dist/types/components/PersonalDetails/types.d.ts

@@ -1,5 +1,7 @@
 import type { BaseInnerFormProps, FormState } from '../../core/hooks/useForm';
 import type { DecisionMakerType } from '../../core/models/api/decision-maker-type';
+import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
+import type { LegalRepresentativeRelationshipType } from '../../core/models/api/legal-entity-association';
 import type { CountryCode } from '../../core/models/country-code';
 import type { TranslationKey } from '../../language/types';
 import type { ValidationRuleResults } from '../../utils/validation/types';
@@ -16,11 +18,13 @@ export interface PersonalDetailsSchema extends NameSchema, IdentityNumberSchema,
     residencyCountry?: CountryCode;
     nationality?: CountryCode;
     jobTitle?: string;
+    relationship?: LegalRepresentativeRelationshipType;
 }
 export interface PersonalDetailsProps extends BaseInnerFormProps<PersonalDetailsSchema> {
     taskType: TaskTypes;
     allowedRoles?: DecisionMakerType[];
     onResidencyCountryChange?(country: string): void;
+    parentLegalEntity?: ExistingLegalEntity;
 }
 export interface IdSchema {
     idNumber: string;

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

@@ -0,0 +1,4 @@
+import type { ProofOfRelationshipProps } from './types';
+declare function ProofOfRelationship({ id, ...props }: ProofOfRelationshipProps): import("preact/compat").JSX.Element;
+declare const _default: typeof ProofOfRelationship;
+export default _default;

package/dist/types/components/ProofOfRelationship/types.d.ts

@@ -0,0 +1,19 @@
+import type { DocumentUploadProps } from '../DocumentUpload/types';
+export declare enum ProofOfRelationshipDocumentTypes {
+    BIRTH_CERTIFICATE = "birthCertificate",
+    GUARDIANSHIP_CERTIFICATE = "guardianshipCertificate",
+    ADOPTION_CERTIFICATE = "adoptionCertificate"
+}
+export declare const proofOfRelationshipDocumentOptions: readonly [{
+    readonly id: ProofOfRelationshipDocumentTypes.BIRTH_CERTIFICATE;
+    readonly name: "birthCertificate";
+}, {
+    readonly id: ProofOfRelationshipDocumentTypes.GUARDIANSHIP_CERTIFICATE;
+    readonly name: "guardianshipCertificate";
+}, {
+    readonly id: ProofOfRelationshipDocumentTypes.ADOPTION_CERTIFICATE;
+    readonly name: "adoptionCertificate";
+}];
+export interface ProofOfRelationshipProps extends DocumentUploadProps {
+    name: string;
+}

package/dist/types/components/StepProgressIndicator/StepProgressIndicator.d.ts

@@ -3,5 +3,6 @@ import type { JSX } from 'preact';
 export interface StepProgressIndicatorProps {
     stepsCount: number;
     activeStepIndex: number;
+    fillBefore?: boolean;
 }
-export declare const StepProgressIndicator: ({ activeStepIndex, stepsCount, }: StepProgressIndicatorProps) => JSX.Element | null;
+export declare const StepProgressIndicator: ({ activeStepIndex, stepsCount, fillBefore, }: StepProgressIndicatorProps) => JSX.Element | null;

package/dist/types/components/TaskList/types.d.ts

@@ -30,7 +30,8 @@ export declare enum TaskTypes {
     SOLE_PROPRIETOR_COMPANY = "SOLE_PROPRIETOR_COMPANY",
     LEGAL_ENTITY_TYPE_SWITCHER = "LEGAL_ENTITY_TYPE_SWITCHER",
     CAPABILITY_REJECTED = "CAPABILITY_REJECTED",
-    SINGPASS_SELECTION = "SINGPASS_SELECTION"
+    SINGPASS_SELECTION = "SINGPASS_SELECTION",
+    LEGAL_REPRESENTATIVE_DETAILS = "LEGAL_REPRESENTATIVE_DETAILS"
 }
 /**
  * Order of TaskStatus enums are used to define the priority of the statuses

package/dist/types/components/internal/Button/Button.d.ts

@@ -2,5 +2,5 @@ import './_button.component.scss';
 import '../Link/_link.component.scss';
 import type { JSX } from 'preact';
 import type { ButtonProps } from './types';
-export declare const Button: ({ showAsLink, secondary, tertiary, className, role, small, block, label, icon, title, disabled, type, onClick, onKeyDown, status, testId, }: ButtonProps) => JSX.Element;
+export declare const Button: ({ showAsLink, secondary, tertiary, className, role, small, block, shaded, label, icon, title, disabled, type, onClick, onKeyDown, status, testId, }: ButtonProps) => JSX.Element;
 export default Button;

package/dist/types/components/internal/Button/types.d.ts

@@ -8,6 +8,7 @@ export interface ButtonProps {
     role?: JSX.AriaRole;
     small?: boolean;
     block?: boolean;
+    shaded?: boolean;
     label?: string;
     icon?: IconName;
     iconOnly?: boolean;

package/dist/types/components/internal/PhoneInput/PhoneInput.d.ts

@@ -1,5 +1,7 @@
+import type { CountryCode } from '../../../core/models/country-code';
 import type { PhoneInputProps, PhoneInputSchema } from './types';
 export declare const phoneFields: (keyof PhoneInputSchema)[];
+export type PhonePrefixes = Partial<Record<CountryCode, string>>;
 declare function PhoneInputComponent(props: PhoneInputProps): import("preact/compat").JSX.Element;
 declare namespace PhoneInputComponent {
     var defaultProps: {

package/dist/types/components/internal/PhoneInput/types.d.ts

@@ -1,10 +1,8 @@
 import type { BaseInnerFormProps } from '../../../core/hooks/useForm';
-import type { DataSet } from '../../../core/models/api/data-set';
 import type { CountryCode } from '../../../core/models/country-code';
 export interface PhoneInputSchema {
     phoneNumber?: string;
 }
 export interface PhoneInputProps extends BaseInnerFormProps<PhoneInputSchema> {
-    phonePrefixes: DataSet;
     country: CountryCode;
 }

package/dist/types/components/internal/PhoneInput/validate.d.ts

@@ -1,6 +1,6 @@
-import type { DataSet } from '../../../core/models/api/data-set';
 import type { AsyncValidatorRules, FormatRules, ValidatorRules } from '../../../utils/validation/types';
+import type { PhonePrefixes } from './PhoneInput';
 import type { PhoneInputSchema } from './types';
-export declare const staticPhoneValidationRules: (phonePrefixes: DataSet, defaultPrefix: string) => ValidatorRules<PhoneInputSchema>;
+export declare const staticPhoneValidationRules: (phonePrefixes: PhonePrefixes | undefined, defaultPrefix: string) => ValidatorRules<PhoneInputSchema>;
 export declare const useAsyncPhoneValidationRules: () => AsyncValidatorRules<PhoneInputSchema>;
 export declare const phoneFormatters: FormatRules<PhoneInputSchema>;

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

@@ -1,3 +1,4 @@
+import type { DatasetIdentifier } from '../../../utils/datasetUtil';
 import type { DataSet } from '../../models/api/data-set';
 import type { GetAllowedCountriesResponse } from '../../models/api/get-allowed-countries';
 import type { GetAllowedLocalesResponse } from '../../models/api/get-allowed-locales';
@@ -9,7 +10,7 @@ export type ConfigurationApi = {
     getConfiguration: (request: GetConfigurationRequest) => Promise<GetConfigurationResponse>;
     getAllowedCountries: () => Promise<GetAllowedCountriesResponse>;
     getAllowedLocales: () => Promise<GetAllowedLocalesResponse>;
-    getDataset: (name: string, locale: string) => Promise<DataSet>;
+    getDataset: (identifier: DatasetIdentifier, locale: string) => Promise<DataSet>;
     loadDocumentGuidance: () => Promise<void>;
     verifyIdNumber: (request: VerifyIdNumberRequest) => Promise<VerifyIdNumberResponse | undefined>;
     validatePhoneNumber: (phoneNumber: string) => Promise<ValidationResponse>;

package/dist/types/core/Services/agnostic/get-dataset.d.ts

@@ -0,0 +1,3 @@
+import type { DatasetIdentifier } from '../../../utils/datasetUtil';
+import type { DataSet } from '../../models/api/data-set';
+export declare const getDataset: (identifier: DatasetIdentifier, locale: string) => Promise<DataSet>;

package/dist/types/core/Services/componentApi/index.d.ts

@@ -2,7 +2,6 @@ export * from './create-document';
 export * from './create-legal-entity';
 export * from './create-transferInstrument';
 export * from './get-bankVerification-vendor';
-export * from './get-dataset';
 export * from './get-document';
 export * from './get-legal-entity';
 export * from './get-scenarios';

package/dist/types/core/Services/kycExternalApi/index.d.ts

@@ -1,6 +1,5 @@
 export * from './get-allowed-countries';
 export * from './get-allowed-locales';
 export * from './get-configuration';
-export * from './get-dataset';
 export * from './validate-phone-number';
 export * from './verify-id-number';

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

@@ -0,0 +1,6 @@
+import type { DropinAPIHandlers } from '../../components/Dropins/types';
+import type { ExistingLegalEntity } from '../models/api/legal-entity';
+export declare const useAssociatedLegalRepresentative: ({ legalEntity, handleGetLegalEntity, }: {
+    legalEntity: ExistingLegalEntity;
+    handleGetLegalEntity?: DropinAPIHandlers["handleGetLegalEntity"];
+}) => ExistingLegalEntity;

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

@@ -1,5 +1,6 @@
+import type { DatasetIdentifier } from '../../utils/datasetUtil';
 import type { DataSet } from '../models/api/data-set';
-export declare function useDataset(datasetIdentifier: string, skip?: boolean): {
-    dataset: DataSet;
+export declare function useDataset<T extends string = string>(datasetIdentifier: DatasetIdentifier, skip?: boolean): {
+    dataset: DataSet<T>;
     loaded: boolean;
 };

package/dist/types/core/models/api/data-set.d.ts

@@ -1,5 +1,5 @@
-export type DataSet = ReadonlyArray<DataSetItem>;
-export interface DataSetItem {
-    id: string;
+export type DataSet<T extends string = string> = ReadonlyArray<DataSetItem<T>>;
+export interface DataSetItem<T> {
+    id: T;
     name: string;
 }

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

@@ -31,5 +31,6 @@ export declare enum DocumentType {
     DRIVING_LICENCE = "driving_licence",
     NATIONAL_IDENTITY_CARD = "national_identity_card",
     RESIDENCE_PERMIT = "residence_permit",
-    PROOF_OF_ORGANIZATION_TAX_INFO = "proofOfOrganizationTaxInfo"
+    PROOF_OF_ORGANIZATION_TAX_INFO = "proofOfOrganizationTaxInfo",
+    PROOF_OF_RELATIONSHIP = "proofOfRelationship"
 }

package/dist/types/core/models/api/legal-entity-association.d.ts

@@ -2,7 +2,8 @@ import type { SettlorExemptionReason } from '../../../components/TrustRoleAndEnt
 import type { DecisionMakerType } from './decision-maker-type';
 import type { LegalEntityType } from './legal-entity-type';
 import type { TrustMemberType } from './trust-member-type';
-export type LegalEntityAssociationType = DecisionMakerType | TrustMemberType | LegalEntityType.TRUST | LegalEntityType.SOLE_PROPRIETORSHIP;
+export type LegalEntityAssociationType = DecisionMakerType | TrustMemberType | LegalEntityType.TRUST | LegalEntityType.SOLE_PROPRIETORSHIP | 'legalRepresentative';
+export type LegalRepresentativeRelationshipType = 'parent' | 'guardian';
 export interface LegalEntityAssociation {
     jobTitle?: string;
     legalEntityId?: string;
@@ -11,4 +12,5 @@ export interface LegalEntityAssociation {
     entityType?: LegalEntityType;
     associatorId?: string;
     settlorExemptionReason?: SettlorExemptionReason[];
+    relationship?: LegalRepresentativeRelationshipType;
 }

package/dist/types/datasets/countries/loadCountries.d.ts

@@ -0,0 +1,3 @@
+import type { DataSet } from '../../core/models/api/data-set';
+import type { CountryCode } from '../../core/models/country-code';
+export declare const loadCountriesDataset: (locale: string) => Promise<DataSet<CountryCode>>;

package/dist/types/datasets/states/loadStatesDataset.d.ts

@@ -0,0 +1,3 @@
+import type { DataSet } from '../../core/models/api/data-set';
+import type { CountryCode } from '../../core/models/country-code';
+export declare const loadStatesDataset: (country: CountryCode, locale: string) => Promise<DataSet>;

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

@@ -0,0 +1,2 @@
+import type { Translations } from './types';
+export declare const loadLocale: (locale: string) => Promise<Translations>;

package/dist/types/utils/birth-date-utils.d.ts

@@ -1,11 +1,24 @@
 import type { PersonalDetailsSchema } from '../components/PersonalDetails/types';
+import { TaskTypes } from '../components/TaskList/types';
+import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
+import type { CountryCode } from '../core/models/country-code';
 import type { Translatable } from '../language/types';
 export declare const getAgeToday: (birthdate: string) => number;
+export declare const getAgeRangeForLegalRepresentative: (country: CountryCode) => {
+    min: number;
+    max: number;
+} | undefined;
 interface TranslatableAlertProps {
     title: Translatable;
     message: Translatable;
 }
-export declare const getLegalRepresentativeWarningMessage: ({ data: { birthDate, residencyCountry }, }: {
+export declare const getLegalRepresentativeWarningMessage: ({ data: { birthDate, residencyCountry }, taskType, }: {
     data: PersonalDetailsSchema;
+    taskType: TaskTypes;
 }) => TranslatableAlertProps | undefined;
+export declare const isAgeWithinRange: (age: number, ageRange: {
+    min: number;
+    max: number;
+}) => boolean;
+export declare const doesLegalEntityRequiresLegalRepresentative: (legalEntity?: ExistingLegalEntity) => boolean;
 export {};

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

@@ -1,15 +1,13 @@
 import type { DataSet } from '../core/models/api/data-set';
 import type { CountryCode } from '../core/models/country-code';
+export type DatasetIdentifier = 'countries' | `states/${CountryCode}`;
 export declare const datasetIdentifier: {
-    country: string;
-    state: (countryCode: CountryCode) => string;
-    phonePrefix: string;
-    translations: string;
+    readonly country: "countries";
+    readonly state: (countryCode: CountryCode) => DatasetIdentifier;
 };
 export type DatasetUtil = {
     getCountryName: (countryCode: CountryCode) => string | null;
     getStateName: (stateCode: string, countryCode: CountryCode) => string | null;
-    getPhonePrefix: (countryCode: CountryCode) => string | null;
     setDataset: (datasetKey: string, dataset: DataSet) => void;
     getDataset: (identifier: string) => DataSet;
     getDatasetKey: (identifier: string) => string;

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

@@ -1,3 +1,5 @@
-export type DynamicImportType<T> = (() => Promise<{
+export type DynamicImportType<T, MightNotExist extends boolean = true> = MightNotExist extends true ? (() => Promise<{
     default: T;
-}>) | undefined;
+}>) | undefined : () => Promise<{
+    default: T;
+}>;

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

@@ -28,3 +28,4 @@ export declare const hasOwnEntityAssociationOfType: (type: LegalEntityType, enti
 export declare const removeEntityAssociationByType: (type: LegalEntityType, entityAssociations: LegalEntityAssociation[], legalEntityId: string | undefined) => LegalEntityAssociation[];
 export declare const isRootLegalEntity: (legalEntity: LegalEntity, taskType: TaskTypes) => boolean;
 export declare const filterOutUnwantedAssociationsIfRootLE: (taskType: TaskTypes, legalEntity: ExistingLegalEntity | undefined, accountHolder: AccountHolderOption | undefined) => LegalEntityAssociation[] | undefined;
+export declare const getLegalRepresentative: (legalEntityResponse: ExistingLegalEntity) => LegalEntityAssociation;

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

@@ -242,6 +242,7 @@ export declare const remediationIndividualApiKeyMapping: {
     passport: string;
     proofOfResidency: string;
     proofOfNationalIdNumber: string;
+    proofOfRelationship: string;
 };
 export declare const remediationPayoutApiKeyMapping: {
     bankStatement: string;

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

@@ -39,7 +39,7 @@ export declare const mapLegalEntityToHighExposure: (legalEntity: LegalEntity) =>
 export declare const mapHighExposureToLegalEntity: (data: HighExposureSchema) => LegalEntity;
 export declare const mapLegalEntityToSoleProp: (legalEntity: LegalEntity) => SolePropSchema;
 export declare const mapSolePropToLegalEntity: (data: SolePropSchema) => LegalEntity;
-export type IndividualDocumentFields = Pick<IndividualSchema, 'idDocument' | 'proofOfResidence' | 'proofOfNationalId'>;
+export type IndividualDocumentFields = Pick<IndividualSchema, 'idDocument' | 'proofOfResidence' | 'proofOfNationalId' | 'proofOfRelationship'>;
 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[]>;

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

@@ -5,7 +5,7 @@ import type { TranslationKey } from '../language/types';
 type Role = `${LegalEntityAssociationType | TrustMemberGuidanceLabel}`;
 type RoleMetadata<R extends Role> = Record<R, {
     name: TranslationKey;
-    variant: TagVariant;
+    variant?: TagVariant;
     description?: TranslationKey;
 }>;
 export declare const roleMetadata: Partial<RoleMetadata<Role>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adyen/kyc-components",
-  "version": "2.48.1",
+  "version": "2.49.0",
   "keywords": [
     "adyen",
     "adyen-kyc",

package/dist/types/components/internal/ContextHelper/ContextHelper.d.ts

@@ -1,6 +0,0 @@
-import './ContextHelper.scss';
-interface ContextHelperProps {
-    content: string;
-}
-export declare const ContextHelper: ({ content }: ContextHelperProps) => import("preact").JSX.Element;
-export {};