@adyen/kyc-components 4.0.0-beta.0 → 4.0.0-beta.3

package/dist/types/stores/globalStore/determineTaskIdentifiers.d.ts

@@ -2,8 +2,8 @@ import type { CapabilityName } from '../../core/models/api/capability';
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
 import type { LegalEntityAssociation } from '../../core/models/api/legal-entity-association';
 import type { TransferInstrumentOverview } from '../../core/models/api/transfer-instrument';
-import type { CapabilityProblems } from '../../core/models/errors/capability-problems';
-import type { AccountHolderOption } from '../../core/types/AccountHolder.types';
+import type { AccountHolderOption } from '../../types/accountHolder';
+import type { CapabilityProblems } from '../../types/errors/capability-problems';
 import type { TrustMember } from '../../components/Trust/tasks/TrustMembers/types';
 import type { UnincorporatedPartnershipMember } from '../../components/UnincorporatedPartnership/tasks/UnincorporatedPartnershipMembers/types';
 import type { TaskIdentifier } from './globalStore';

package/dist/types/stores/globalStore/get-task-status.d.ts

@@ -1,5 +1,5 @@
 import type { ExistingLegalEntity, LegalEntity } from '../../core/models/api/legal-entity';
-import type { CapabilityProblems } from '../../core/models/errors/capability-problems';
+import type { CapabilityProblems } from '../../types/errors/capability-problems';
 import type { TaskStatusWithReason } from './taskStatus';
 import { TaskTypes } from './taskTypes';
 export declare const calculateCustomerSupportTask: (capabilityProblems: CapabilityProblems, rootLegalEntity: ExistingLegalEntity) => TaskStatusWithReason;

package/dist/types/stores/globalStore/globalStore.d.ts

@@ -3,9 +3,9 @@ import type { CapabilityName } from '../../core/models/api/capability';
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
 import type { LegalEntityAssociation } from '../../core/models/api/legal-entity-association';
 import type { TransferInstrumentOverview } from '../../core/models/api/transfer-instrument';
-import type { CountryCode } from '../../core/models/country-code';
-import type { CapabilityProblems } from '../../core/models/errors/capability-problems';
-import type { AccountHolderOption } from '../../core/types/AccountHolder.types';
+import type { AccountHolderOption } from '../../types/accountHolder';
+import type { CountryCode } from '../../types/datasets/country-code';
+import type { CapabilityProblems } from '../../types/errors/capability-problems';
 import type { TrustMember } from '../../components/Trust/tasks/TrustMembers/types';
 import type { UnincorporatedPartnershipMember } from '../../components/UnincorporatedPartnership/tasks/UnincorporatedPartnershipMembers/types';
 import type { TaskStatusWithReason } from './taskStatus';
@@ -38,7 +38,7 @@ type TaskStatuses = Partial<Record<TaskIdentifier, TaskStatusWithReason>>;
 export declare const createGlobalStore: ({ rootLegalEntity: rootLegalEntityIn, }: {
     rootLegalEntity: ExistingLegalEntity;
 }) => GlobalStore;
-export declare const StoreContext: import("preact").Context<GlobalStore>;
+export declare const StoreContext: import("preact").Context<GlobalStore | null>;
 export declare function useGlobalStore(): GlobalStore;
 export declare const useGetTaskStatus: () => (taskType: TaskTypes, id?: string) => TaskStatus;
 export {};

package/dist/types/stores/globalStore/taskStatus.d.ts

@@ -1,4 +1,4 @@
-import type { ApiTaskStatus, TaskStatusEntry } from '../../api/taskStatus/useTaskStatus';
+import type { ApiTaskStatus, TaskStatusEntry } from '../../api/taskStatus/taskStatus.types';
 import type { TaskTypes } from '../globalStore/taskTypes';
 /**
  * Order of TaskStatus enums are used to define the priority of the statuses

package/dist/types/types/datasets/country-code.d.ts

@@ -0,0 +1,251 @@
+export type CountryCode = (typeof CountryCodes)[keyof typeof CountryCodes];
+export declare const CountryCodes: {
+    readonly Afghanistan: "AF";
+    readonly AlandIslands: "AX";
+    readonly Albania: "AL";
+    readonly Algeria: "DZ";
+    readonly AmericanSamoa: "AS";
+    readonly Andorra: "AD";
+    readonly Angola: "AO";
+    readonly Anguilla: "AI";
+    readonly Antarctica: "AQ";
+    readonly AntiguaAndBarbuda: "AG";
+    readonly Argentina: "AR";
+    readonly Armenia: "AM";
+    readonly Aruba: "AW";
+    readonly Australia: "AU";
+    readonly Austria: "AT";
+    readonly Azerbaijan: "AZ";
+    readonly Bahamas: "BS";
+    readonly Bahrain: "BH";
+    readonly Bangladesh: "BD";
+    readonly Barbados: "BB";
+    readonly Belarus: "BY";
+    readonly Belgium: "BE";
+    readonly Belize: "BZ";
+    readonly Benin: "BJ";
+    readonly Bermuda: "BM";
+    readonly Bhutan: "BT";
+    readonly Bolivia: "BO";
+    readonly BonaireSintEustatiusSaba: "BQ";
+    readonly BosniaAndHerzegovina: "BA";
+    readonly Botswana: "BW";
+    readonly BouvetIsland: "BV";
+    readonly Brazil: "BR";
+    readonly BritishIndianOceanTerritory: "IO";
+    readonly BruneiDarussalam: "BN";
+    readonly Bulgaria: "BG";
+    readonly BurkinaFaso: "BF";
+    readonly Burundi: "BI";
+    readonly Cambodia: "KH";
+    readonly Cameroon: "CM";
+    readonly Canada: "CA";
+    readonly CapeVerde: "CV";
+    readonly CaymanIslands: "KY";
+    readonly CentralAfricanRepublic: "CF";
+    readonly Chad: "TD";
+    readonly Chile: "CL";
+    readonly China: "CN";
+    readonly ChristmasIsland: "CX";
+    readonly CocosKeelingIslands: "CC";
+    readonly Colombia: "CO";
+    readonly Comoros: "KM";
+    readonly Congo: "CG";
+    readonly CongoDemocraticRepublic: "CD";
+    readonly CookIslands: "CK";
+    readonly CostaRica: "CR";
+    readonly CoteDIvoire: "CI";
+    readonly Croatia: "HR";
+    readonly Cuba: "CU";
+    readonly Curacao: "CW";
+    readonly Cyprus: "CY";
+    readonly CzechRepublic: "CZ";
+    readonly Denmark: "DK";
+    readonly Djibouti: "DJ";
+    readonly Dominica: "DM";
+    readonly DominicanRepublic: "DO";
+    readonly Ecuador: "EC";
+    readonly Egypt: "EG";
+    readonly ElSalvador: "SV";
+    readonly EquatorialGuinea: "GQ";
+    readonly Eritrea: "ER";
+    readonly Estonia: "EE";
+    readonly Ethiopia: "ET";
+    readonly FalklandIslands: "FK";
+    readonly FaroeIslands: "FO";
+    readonly Fiji: "FJ";
+    readonly Finland: "FI";
+    readonly France: "FR";
+    readonly FrenchGuiana: "GF";
+    readonly FrenchPolynesia: "PF";
+    readonly FrenchSouthernTerritories: "TF";
+    readonly Gabon: "GA";
+    readonly Gambia: "GM";
+    readonly Georgia: "GE";
+    readonly Germany: "DE";
+    readonly Ghana: "GH";
+    readonly Gibraltar: "GI";
+    readonly Greece: "GR";
+    readonly Greece_ISO_639_1: "EL";
+    readonly Greenland: "GL";
+    readonly Grenada: "GD";
+    readonly Guadeloupe: "GP";
+    readonly Guam: "GU";
+    readonly Guatemala: "GT";
+    readonly Guernsey: "GG";
+    readonly Guinea: "GN";
+    readonly GuineaBissau: "GW";
+    readonly Guyana: "GY";
+    readonly Haiti: "HT";
+    readonly HeardIslandMcdonaldIslands: "HM";
+    readonly HolySeeVaticanCityState: "VA";
+    readonly Honduras: "HN";
+    readonly HongKong: "HK";
+    readonly Hungary: "HU";
+    readonly Iceland: "IS";
+    readonly India: "IN";
+    readonly Indonesia: "ID";
+    readonly Iran: "IR";
+    readonly Iraq: "IQ";
+    readonly Ireland: "IE";
+    readonly IsleOfMan: "IM";
+    readonly Israel: "IL";
+    readonly Italy: "IT";
+    readonly Jamaica: "JM";
+    readonly Japan: "JP";
+    readonly Jersey: "JE";
+    readonly Jordan: "JO";
+    readonly Kazakhstan: "KZ";
+    readonly Kenya: "KE";
+    readonly Kiribati: "KI";
+    readonly Korea: "KR";
+    readonly KoreaDemocraticPeoplesRepublic: "KP";
+    readonly Kuwait: "KW";
+    readonly Kyrgyzstan: "KG";
+    readonly LaoPeoplesDemocraticRepublic: "LA";
+    readonly Latvia: "LV";
+    readonly Lebanon: "LB";
+    readonly Lesotho: "LS";
+    readonly Liberia: "LR";
+    readonly LibyanArabJamahiriya: "LY";
+    readonly Liechtenstein: "LI";
+    readonly Lithuania: "LT";
+    readonly Luxembourg: "LU";
+    readonly Macao: "MO";
+    readonly Macedonia: "MK";
+    readonly Madagascar: "MG";
+    readonly Malawi: "MW";
+    readonly Malaysia: "MY";
+    readonly Maldives: "MV";
+    readonly Mali: "ML";
+    readonly Malta: "MT";
+    readonly MarshallIslands: "MH";
+    readonly Martinique: "MQ";
+    readonly Mauritania: "MR";
+    readonly Mauritius: "MU";
+    readonly Mayotte: "YT";
+    readonly Mexico: "MX";
+    readonly Micronesia: "FM";
+    readonly Moldova: "MD";
+    readonly Monaco: "MC";
+    readonly Mongolia: "MN";
+    readonly Montenegro: "ME";
+    readonly Montserrat: "MS";
+    readonly Morocco: "MA";
+    readonly Mozambique: "MZ";
+    readonly Myanmar: "MM";
+    readonly Namibia: "NA";
+    readonly Nauru: "NR";
+    readonly Nepal: "NP";
+    readonly Netherlands: "NL";
+    readonly NewCaledonia: "NC";
+    readonly NewZealand: "NZ";
+    readonly Nicaragua: "NI";
+    readonly Niger: "NE";
+    readonly Nigeria: "NG";
+    readonly Niue: "NU";
+    readonly NorfolkIsland: "NF";
+    readonly NorthernMarianaIslands: "MP";
+    readonly Norway: "NO";
+    readonly Oman: "OM";
+    readonly Pakistan: "PK";
+    readonly Palau: "PW";
+    readonly PalestinianTerritory: "PS";
+    readonly Panama: "PA";
+    readonly PapuaNewGuinea: "PG";
+    readonly Paraguay: "PY";
+    readonly Peru: "PE";
+    readonly Philippines: "PH";
+    readonly Pitcairn: "PN";
+    readonly Poland: "PL";
+    readonly Portugal: "PT";
+    readonly PuertoRico: "PR";
+    readonly Qatar: "QA";
+    readonly Reunion: "RE";
+    readonly Romania: "RO";
+    readonly RussianFederation: "RU";
+    readonly Rwanda: "RW";
+    readonly SaintHelena: "SH";
+    readonly SaintKittsAndNevis: "KN";
+    readonly SaintLucia: "LC";
+    readonly SaintPierreAndMiquelon: "PM";
+    readonly SaintVincentAndGrenadines: "VC";
+    readonly Samoa: "WS";
+    readonly SanMarino: "SM";
+    readonly SaoTomeAndPrincipe: "ST";
+    readonly SaudiArabia: "SA";
+    readonly Senegal: "SN";
+    readonly Serbia: "RS";
+    readonly Seychelles: "SC";
+    readonly SierraLeone: "SL";
+    readonly Singapore: "SG";
+    readonly Slovakia: "SK";
+    readonly Slovenia: "SI";
+    readonly SolomonIslands: "SB";
+    readonly Somalia: "SO";
+    readonly SouthAfrica: "ZA";
+    readonly SouthGeorgiaAndSandwichIsl: "GS";
+    readonly Spain: "ES";
+    readonly SriLanka: "LK";
+    readonly Sudan: "SD";
+    readonly Suriname: "SR";
+    readonly SvalbardAndJanMayen: "SJ";
+    readonly Swaziland: "SZ";
+    readonly Sweden: "SE";
+    readonly Switzerland: "CH";
+    readonly SyrianArabRepublic: "SY";
+    readonly Taiwan: "TW";
+    readonly Tajikistan: "TJ";
+    readonly Tanzania: "TZ";
+    readonly Thailand: "TH";
+    readonly TimorLeste: "TL";
+    readonly Togo: "TG";
+    readonly Tokelau: "TK";
+    readonly Tonga: "TO";
+    readonly TrinidadAndTobago: "TT";
+    readonly Tunisia: "TN";
+    readonly Turkey: "TR";
+    readonly Turkmenistan: "TM";
+    readonly TurksAndCaicosIslands: "TC";
+    readonly Tuvalu: "TV";
+    readonly Uganda: "UG";
+    readonly Ukraine: "UA";
+    readonly UnitedArabEmirates: "AE";
+    readonly UnitedKingdom: "GB";
+    readonly UnitedStates: "US";
+    readonly UnitedStatesOutlyingIslands: "UM";
+    readonly Uruguay: "UY";
+    readonly Uzbekistan: "UZ";
+    readonly Vanuatu: "VU";
+    readonly Venezuela: "VE";
+    readonly Vietnam: "VN";
+    readonly VirginIslandsBritish: "VG";
+    readonly VirginIslandsUS: "VI";
+    readonly WallisAndFutuna: "WF";
+    readonly WesternSahara: "EH";
+    readonly Yemen: "YE";
+    readonly Zambia: "ZM";
+    readonly Zimbabwe: "ZW";
+};
+export declare const euCountries: CountryCode[];
+export declare const HK_SG_COUNTRIES: CountryCode[];

package/dist/types/{core/models → types}/errors/capability-problems.d.ts

@@ -1,4 +1,4 @@
-import type { EntityType } from '../api/entity-type';
+import type { EntityType } from '../../core/models/api/entity-type';
 import type { EntityProblems } from './entity-problems';
 export type CapabilityProblems = {
     [entityType in EntityType]?: {

package/dist/types/{core/models → types}/errors/entity-problems.d.ts

@@ -1,7 +1,7 @@
-import type { TaskStatusWithReason } from '../../../stores/globalStore/taskStatus';
-import type { EntityType } from '../api/entity-type';
-import type { LegalEntityType } from '../api/legal-entity-type';
-import type { VerificationError } from '../api/verification-error';
+import type { EntityType } from '../../core/models/api/entity-type';
+import type { LegalEntityType } from '../../core/models/api/legal-entity-type';
+import type { VerificationError } from '../../core/models/api/verification-error';
+import type { TaskStatusWithReason } from '../../stores/globalStore/taskStatus';
 import type { FormVerificationErrors } from './form-verification-errors';
 import type { Remediation, RemediationCode } from './remediation';
 type FormValidationErrors = {

package/dist/types/{core/models → types}/errors/error-message.d.ts

@@ -1,2 +1,2 @@
-import type { TranslationKey } from '../../../../types';
+import type { TranslationKey } from '../../../types';
 export type ErrorCode = Extract<TranslationKey, `errorMessage_${string}`> extends `errorMessage_${infer R}` ? R : never;

package/dist/types/{core/models → types}/errors/maintenance-mode-error.d.ts

@@ -1 +1 @@
-export declare const isMaintenanceModeError: (error: unknown) => boolean;
+export declare const isMaintenanceModeError: (error: unknown) => unknown;

package/dist/types/{core/models → types}/errors/remediation.d.ts

@@ -1,4 +1,4 @@
-import type { TranslationKey } from '../../../../types';
+import type { TranslationKey } from '../../../types';
 export type RemediationCode = Extract<TranslationKey, `remediationMessage_${string}`> extends `remediationMessage_${infer R}` ? R : never;
 export interface Remediation {
     code: RemediationCode;

package/dist/types/{core/models → types}/form-configuration.d.ts

@@ -1,8 +1,8 @@
 import type { AllUnionFields, ValueOf } from 'type-fest';
-import type { TopLevelDataSchema } from '../../context/StateContext/types';
-import type { TranslationKey } from '../../../types';
-import type { Scenario } from './api/get-scenarios';
-import type { PerCountry } from '../../utils/perCountry';
+import type { TopLevelDataSchema } from '../context/StateContext/types';
+import type { TranslationKey } from '../../types';
+import type { Scenario } from '../core/models/api/get-scenarios';
+import type { PerCountry } from '../utils/perCountry';
 export interface FieldSettings<RuleName extends string> {
     obscured?: boolean;
     rule?: RuleName | 'REQUIRED' | 'OPTIONAL';

package/dist/types/{core/models → types}/form-rules.d.ts

@@ -1,11 +1,12 @@
-import type { ExperimentName } from '../../context/ExperimentContext/types';
-import type { TopLevelDataSchema } from '../../context/StateContext/types';
-import type { AccountFormatRequirements } from '../../datasets/generators/getAccountFormatForCountry';
-import type { Scenario } from './api/get-scenarios';
-import type { TaskTypes } from '../../stores/globalStore/taskTypes';
-import type { AccountHolderOption } from '../types/AccountHolder.types';
-import type { ExistingLegalEntity } from './api/legal-entity';
-import type { CountryCode } from './country-code';
+import type { ExperimentName } from '../context/ExperimentContext/types';
+import type { TopLevelDataSchema } from '../context/StateContext/types';
+import type { AccountFormatRequirements } from '../datasets/generators/getAccountFormatForCountry';
+import type { Scenario } from '../core/models/api/get-scenarios';
+import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
+import type { TaskTypes } from '../stores/globalStore/taskTypes';
+import type { AccountHolderOption } from './accountHolder';
+import type { CountryCode } from './datasets/country-code';
+import type { EntityProblems } from './errors/entity-problems';
 export interface FormRulesParams<TLDS extends TopLevelDataSchema> {
     matchingScenario?: Scenario[];
     data: TLDS;
@@ -16,6 +17,7 @@ export interface FormRulesParams<TLDS extends TopLevelDataSchema> {
     rootLegalEntity?: ExistingLegalEntity;
     accountHolder?: AccountHolderOption;
     tinMatched?: boolean;
+    problems?: EntityProblems;
 }
 type FieldRule = () => 'REQUIRED' | 'OPTIONAL' | undefined;
 export type FormRules<RuleName extends string> = Record<RuleName, FieldRule>;

package/dist/types/{core/models → types}/form.d.ts

@@ -1,4 +1,4 @@
-import type { TranslationKey } from '../../../types';
+import type { TranslationKey } from '../../types';
 export interface FormModel {
     formId: string;
     formName: TranslationKey;

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

@@ -1,6 +1,6 @@
 import type { CapabilityName } from '../core/models/api/capability';
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
-import type { AccountHolderOption } from '../core/types/AccountHolder.types';
+import type { AccountHolderOption } from '../types/accountHolder';
 /**
  ** Account holder option 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

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

@@ -1,7 +1,7 @@
 import type { Attachment } from '../../core/models/api/attachment';
 import type { Document, DocumentDetail, DocumentEntityType, DocumentType, ExistingDocument, ExistingDocumentWithModificationDate } from '../../core/models/api/document';
-import type { FileSchema } from '../../core/models/file';
 import type { ComponentApiRequestContext } from '../../core/services/types';
+import type { FileSchema } from '../../types/file';
 export type DocumentApiUtils = {
     fetchDocuments(documentDetails: DocumentDetail[], entityId: string): Promise<Document[]>;
     fetchDocument(documentDetail: DocumentDetail, entityId: string): Promise<Document>;

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

@@ -1,5 +1,5 @@
 import type { EntityType } from '../../core/models/api/entity-type';
-import type { CapabilityProblems } from '../../core/models/errors/capability-problems';
-import type { EntityProblems } from '../../core/models/errors/entity-problems';
+import type { CapabilityProblems } from '../../types/errors/capability-problems';
+import type { EntityProblems } from '../../types/errors/entity-problems';
 export declare const useCapabilityProblems: () => CapabilityProblems | undefined;
 export declare const getProblemsForEntity: (capabilityProblems: CapabilityProblems, entityType: EntityType, entityId: string) => EntityProblems | undefined;

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

@@ -1,9 +1,10 @@
+import type { ExperimentName } from '../../context/ExperimentContext/types';
 import type { CapabilityName } from '../../core/models/api/capability';
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
 import type { ExistingTransferInstrument } from '../../core/models/api/transfer-instrument';
-import type { CountryCode } from '../../core/models/country-code';
-import type { CapabilityProblems } from '../../core/models/errors/capability-problems';
-import type { Remediation } from '../../core/models/errors/remediation';
-export declare function getCapabilityProblems(entity: ExistingLegalEntity | ExistingTransferInstrument, country: CountryCode): CapabilityProblems;
+import type { CountryCode } from '../../types/datasets/country-code';
+import type { CapabilityProblems } from '../../types/errors/capability-problems';
+import type { Remediation } from '../../types/errors/remediation';
+export declare function getCapabilityProblems(entity: ExistingLegalEntity | ExistingTransferInstrument, country: CountryCode, isExperimentEnabled?: (key: ExperimentName) => boolean): CapabilityProblems;
 export declare const remediationHasFileUploadField: (remediation: Remediation) => boolean;
 export declare const getCapabilities: (legalEntity?: ExistingLegalEntity) => CapabilityName[];

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

@@ -1,6 +1,6 @@
-import type { ValidationError } from '../../core/models/errors/validation-error';
-import type { EntityProblems } from '../../core/models/errors/entity-problems';
 import { TaskTypes } from '../../stores/globalStore/taskTypes';
+import type { EntityProblems } from '../../types/errors/entity-problems';
+import type { ValidationError } from '../validationError';
 /**
  * Processes server validation errors received from an erroneous HTTP response.
  * @param validationError - the validation error contain all invalid fields.
@@ -8,5 +8,5 @@ import { TaskTypes } from '../../stores/globalStore/taskTypes';
  * @param keyMappings - the actual keymappings, for non-task components
  */
 export declare const processValidationErrors: <T extends string>(validationError: ValidationError, dropinTask?: TaskTypes, keyMappings?: {
-    [key: string]: T;
+    [key: string]: T | undefined;
 }) => EntityProblems["validationErrors"];

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

@@ -1,15 +1,66 @@
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
 import type { Translatable } from '../../types';
 import { TaskTypes } from '../stores/globalStore/taskTypes';
+import type { CountryCode } from '../types/datasets/country-code';
 import type { PersonalDetailsSchema } from '../components/Individual/forms/Individual/PersonalDetails/types';
+/**
+ * Calculates the age of a person based on their birthdate.
+ * @param birthdate - The birthdate of the person in 'YYYY-MM-DD' format.
+ * @returns The age of the person in years.
+ */
 export declare const getAgeToday: (birthdate: string) => number;
+/**
+ * Returns the age range for a legal representative based on the country.
+ * @param country - The country code.
+ * @returns An object with min and max age, or undefined if not applicable.
+ */
+export declare const getAgeRangeForLegalRepresentative: (country?: CountryCode) => {
+    min: number;
+    max: number;
+} | undefined;
 interface TranslatableAlertProps {
     title: Translatable;
     message: Translatable;
 }
-export declare const getLegalRepresentativeWarningMessage: ({ data: { birthDate, residencyCountry }, taskType, }: {
-    data: PersonalDetailsSchema;
+/**
+ * Checks if a person is under the required age for KYC based on their birthdate and country.
+ * @param birthDate - The birthdate of the person.
+ * @param country - The country of residence.
+ * @returns True if the person is under the required age, false otherwise.
+ */
+export declare const isPersonUnderAge: (birthDate?: string, country?: CountryCode) => boolean;
+/**
+ * Determines if a legal representative is needed based on age, country, and task type.
+ * @param birthDate - The birthdate of the person.
+ * @param country - The country of residence.
+ * @param taskType - The type of task being performed.
+ * @returns True if a legal representative is needed, false otherwise.
+ */
+export declare const isLegalRepresentativeNeeded: (birthDate?: string, country?: CountryCode, taskType?: TaskTypes) => boolean;
+/**
+ * Generates a warning message if a legal representative is required.
+ * @param data - The personalDetails data.
+ * @param taskType - The type of task.
+ * @returns A translatable alert object or undefined.
+ */
+export declare const getLegalRepresentativeWarningMessage: ({ data, taskType, }: {
+    data: PersonalDetailsSchema | undefined;
     taskType: TaskTypes;
 }) => TranslatableAlertProps | undefined;
+/**
+ * Checks if an age is within a given range.
+ * @param age - The age to check.
+ * @param ageRange - An object with min and max age.
+ * @returns True if the age is within the range, false otherwise.
+ */
+export declare const isAgeWithinRange: (age: number, ageRange: {
+    min: number;
+    max: number;
+}) => boolean;
+/**
+ * Checks if a legal entity requires a legal representative based on the individual's age.
+ * @param legalEntity - The existing legal entity.
+ * @returns True if a legal representative is required, false otherwise.
+ */
 export declare const doesLegalEntityRequiresLegalRepresentative: (legalEntity?: ExistingLegalEntity) => boolean;
 export {};

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

@@ -1,3 +1,6 @@
-export declare const isEeaCountry: (country?: string) => boolean;
-export declare const isLowRiskCountry: (country?: string) => boolean;
+import type { CountryCode } from '../types/datasets/country-code';
+export declare const isEuCountry: (country?: string) => country is CountryCode;
+export declare const isEeaCountry: (country?: string) => country is CountryCode;
+export declare const isLowRiskCountry: (country?: string) => country is CountryCode;
 export declare const isUK: (countryCode?: string) => boolean;
+export declare const isHkSgCountry: (country?: string) => country is CountryCode;

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

@@ -1,7 +1,7 @@
 import type { DataSet } from '../core/models/api/data-set';
-import type { CountryCode } from '../core/models/country-code';
-import type { ProvinceCode } from '../core/models/province-code';
-import type { StateCode } from '../core/models/state-code';
+import type { CountryCode } from '../types/datasets/country-code';
+import type { ProvinceCode } from '../types/datasets/province-code';
+import type { StateCode } from '../types/datasets/state-code';
 export type DatasetIdentifier = 'countries' | `states/${CountryCode}`;
 export declare const datasetIdentifier: {
     readonly country: "countries";

package/dist/types/{core/models/decision-maker.d.ts → utils/decisionMaker.d.ts}

@@ -1,5 +1,5 @@
-import type { TranslationKey } from '../../../types';
-import { DecisionMakerType } from './api/decision-maker-type';
+import type { TranslationKey } from '../../types';
+import { DecisionMakerType } from '../core/models/api/decision-maker-type';
 /**
  *
  * When providing DECISION_MAKER_REQUIREMENTS per country - keep in mind that you need to specify rules for each role individually even if you have a mixed rule between them.

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

@@ -1,5 +1,5 @@
-import type { EntityProblems } from '../core/models/errors/entity-problems';
-import type { FormList, FormModel, FormModelWithValidity } from '../core/models/form';
+import type { EntityProblems } from '../types/errors/entity-problems';
+import type { FormList, FormModel, FormModelWithValidity } from '../types/form';
 /**
  * @@description Based requiredfields and optionalFields determine what forms need to be shown and add a summaryStep in the dropin
  *

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

@@ -1,12 +1,11 @@
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
 import type { LegalEntityAssociation, NomineeType } from '../core/models/api/legal-entity-association';
 import { LegalEntityType } from '../core/models/api/legal-entity-type';
-import type { CountryCode } from '../core/models/country-code';
-import { CountryCodes } from '../core/models/country-code';
-import type { CapabilityProblems } from '../core/models/errors/capability-problems';
-import type { EntityProblems } from '../core/models/errors/entity-problems';
-import type { AccountHolderOption } from '../core/types/AccountHolder.types';
 import { TaskTypes } from '../stores/globalStore/taskTypes';
+import type { AccountHolderOption } from '../types/accountHolder';
+import type { CountryCode } from '../types/datasets/country-code';
+import type { CapabilityProblems } from '../types/errors/capability-problems';
+import type { EntityProblems } from '../types/errors/entity-problems';
 import type { PersonalDetailsSchema } from '../components/Individual/forms/Individual/PersonalDetails/types';
 import type { BasicDetailsSchema } from '../components/Individual/forms/IndividualOnfido/BasicDetails/BasicDetails.types';
 /**
@@ -24,8 +23,8 @@ export declare const getOwnSolePropProblems: (rootLegalEntity: ExistingLegalEnti
 export declare const hasOwnEntityAssociationOfType: (type: LegalEntityType, entityAssociations: LegalEntityAssociation[] | undefined, legalEntityId: string | undefined) => boolean;
 export declare const removeEntityAssociationByType: (type: LegalEntityType, entityAssociations: LegalEntityAssociation[], legalEntityId: string | undefined) => LegalEntityAssociation[];
 export declare const filterOutUnwantedAssociationsIfRootLE: (taskType: TaskTypes, legalEntity: ExistingLegalEntity | undefined, accountHolder: AccountHolderOption | undefined) => LegalEntityAssociation[] | undefined;
-export declare const getLegalRepresentative: (legalEntityResponse: ExistingLegalEntity) => LegalEntityAssociation;
+export declare const getLegalRepresentative: (legalEntityResponse: ExistingLegalEntity) => LegalEntityAssociation | undefined;
 export declare const allowedCountriesForNominee: CountryCode[];
-export declare const attachNomineeToRole: (existingEntityAssociation: LegalEntityAssociation, country: CountryCodes, nominee?: NomineeType) => LegalEntityAssociation;
+export declare const attachNomineeToRole: (existingEntityAssociation: LegalEntityAssociation, country: CountryCode, nominee?: NomineeType) => LegalEntityAssociation;
 export declare const getNomineeFromAssociation: (entityAssociations: LegalEntityAssociation[], personalDetails: PersonalDetailsSchema | BasicDetailsSchema) => PersonalDetailsSchema;
 export declare const hasNomineesChanged: (personalDetails?: PersonalDetailsSchema, nomineesSubmitted?: NomineeType) => boolean;