@adyen/kyc-components 4.0.0-beta.1 → 4.0.0-beta.4

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

@@ -1,48 +1,48 @@
 export type ProvinceCode = ProvinceCodeAU | ProvinceCodeCA | ProvinceCodeNZ;
-type ProvinceCodeAU = `${ProvinceCodesAU}`;
-declare const enum ProvinceCodesAU {
-    AustralianCapitalTerritory = "ACT",
-    NewSouthWales = "NSW",
-    NorthernTerritory = "NT",
-    Queensland = "QLD",
-    SouthAustralia = "SA",
-    Tasmania = "TAS",
-    Victoria = "VIC",
-    WesternAustralia = "WA"
-}
-type ProvinceCodeCA = `${ProvinceCodesCA}`;
-export declare const enum ProvinceCodesCA {
-    Alberta = "AB",
-    BritishColumbia = "BC",
-    Manitoba = "MB",
-    NewBrunswick = "NB",
-    NewfoundlandAndLabrador = "NL",
-    NorthwestTerritories = "NT",
-    NovaScotia = "NS",
-    Nunavut = "NU",
-    Ontario = "ON",
-    PrinceEdwardIsland = "PE",
-    Quebec = "QC",
-    Saskatchewan = "SK",
-    Yukon = "YT"
-}
-type ProvinceCodeNZ = `${ProvinceCodesNZ}`;
-export declare const enum ProvinceCodesNZ {
-    Auckland = "AUK",
-    BayOfPlenty = "BOP",
-    Canterbury = "CAN",
-    Gisborne = "GIS",
-    HawkesBay = "HKB",
-    Marlborough = "MBH",
-    ManawatuWanganui = "MWT",
-    Nelson = "NSN",
-    Otago = "OTA",
-    SouthLand = "STL",
-    Tasman = "TAS",
-    Taranaki = "TKI",
-    Waikato = "WKO",
-    Wellington = "WGN",
-    WestCoast = "WTC",
-    ChathamIslandsTerritory = "CIT"
-}
+type ProvinceCodeAU = (typeof _ProvinceCodesAU)[keyof typeof _ProvinceCodesAU];
+declare const _ProvinceCodesAU: {
+    readonly AustralianCapitalTerritory: "ACT";
+    readonly NewSouthWales: "NSW";
+    readonly NorthernTerritory: "NT";
+    readonly Queensland: "QLD";
+    readonly SouthAustralia: "SA";
+    readonly Tasmania: "TAS";
+    readonly Victoria: "VIC";
+    readonly WesternAustralia: "WA";
+};
+type ProvinceCodeCA = (typeof ProvinceCodesCA)[keyof typeof ProvinceCodesCA];
+export declare const ProvinceCodesCA: {
+    readonly Alberta: "AB";
+    readonly BritishColumbia: "BC";
+    readonly Manitoba: "MB";
+    readonly NewBrunswick: "NB";
+    readonly NewfoundlandAndLabrador: "NL";
+    readonly NorthwestTerritories: "NT";
+    readonly NovaScotia: "NS";
+    readonly Nunavut: "NU";
+    readonly Ontario: "ON";
+    readonly PrinceEdwardIsland: "PE";
+    readonly Quebec: "QC";
+    readonly Saskatchewan: "SK";
+    readonly Yukon: "YT";
+};
+type ProvinceCodeNZ = (typeof ProvinceCodesNZ)[keyof typeof ProvinceCodesNZ];
+export declare const ProvinceCodesNZ: {
+    readonly Auckland: "AUK";
+    readonly BayOfPlenty: "BOP";
+    readonly Canterbury: "CAN";
+    readonly Gisborne: "GIS";
+    readonly HawkesBay: "HKB";
+    readonly Marlborough: "MBH";
+    readonly ManawatuWanganui: "MWT";
+    readonly Nelson: "NSN";
+    readonly Otago: "OTA";
+    readonly SouthLand: "STL";
+    readonly Tasman: "TAS";
+    readonly Taranaki: "TKI";
+    readonly Waikato: "WKO";
+    readonly Wellington: "WGN";
+    readonly WestCoast: "WTC";
+    readonly ChathamIslandsTerritory: "CIT";
+};
 export {};

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

@@ -1,86 +1,86 @@
 export type StateCode = StateCodeUS | StateCodeBR;
-export type StateCodeBR = `${StateCodesBR}`;
-declare const enum StateCodesBR {
-    Acre = "AC",
-    Alagoas = "AL",
-    Amazonas = "AM",
-    Amapá = "AP",
-    Bahia = "BA",
-    Ceará = " CE",
-    DistritoFederal = "DF",
-    EspíritoSanto = "ES",
-    Goiás = "GO",
-    Maranhão = "MA",
-    MinasGerais = "MG",
-    MatoGrossodoSul = "MS",
-    MatoGrosso = "MT",
-    Pará = "PA",
-    Paraíba = "PB",
-    Pernambuco = "PE",
-    Piauí = "PI",
-    Paraná = "PR",
-    RiodeJaneiro = "RJ",
-    RioGrandedoNorte = "RN",
-    Rondônia = "RO",
-    Roraima = "RR",
-    RioGrandedoSul = "RS",
-    SantaCatarina = "SC",
-    Sergipe = "SE",
-    SãoPaulo = "SP",
-    Tocantins = "TO"
-}
-export type StateCodeUS = `${StateCodesUS}`;
-export declare const enum StateCodesUS {
-    Alabama = "AL",
-    Alaska = "AK",
-    Arizona = "AZ",
-    Arkansas = "AR",
-    California = "CA",
-    Colorado = "CO",
-    Connecticut = "CT",
-    Delaware = "DE",
-    DistrictOfColumbia = "DC",
-    Florida = "FL",
-    Georgia = "GA",
-    Hawaii = "HI",
-    Idaho = "ID",
-    Illinois = "IL",
-    Indiana = "IN",
-    Iowa = "IA",
-    Kansas = "KS",
-    Kentucky = "KY",
-    Louisiana = "LA",
-    Maine = "ME",
-    Maryland = "MD",
-    Massachusetts = "MA",
-    Michigan = "MI",
-    Minnesota = "MN",
-    Mississippi = "MS",
-    Missouri = "MO",
-    Montana = "MT",
-    Nebraska = "NE",
-    Nevada = "NV",
-    NewHampshire = "NH",
-    NewJersey = "NJ",
-    NewMexico = "NM",
-    NewYork = "NY",
-    NorthCarolina = "NC",
-    NorthDakota = "ND",
-    Ohio = "OH",
-    Oklahoma = "OK",
-    Oregon = "OR",
-    Pennsylvania = "PA",
-    RhodeIsland = "RI",
-    SouthCarolina = "SC",
-    SouthDakota = "SD",
-    Tennessee = "TN",
-    Texas = "TX",
-    Utah = "UT",
-    Vermont = "VT",
-    Virginia = "VA",
-    Washington = "WA",
-    WestVirginia = "WV",
-    Wisconsin = "WI",
-    Wyoming = "WY"
-}
+export type StateCodeBR = (typeof _StateCodesBR)[keyof typeof _StateCodesBR];
+declare const _StateCodesBR: {
+    readonly Acre: "AC";
+    readonly Alagoas: "AL";
+    readonly Amazonas: "AM";
+    readonly Amapá: "AP";
+    readonly Bahia: "BA";
+    readonly Ceará: " CE";
+    readonly DistritoFederal: "DF";
+    readonly EspíritoSanto: "ES";
+    readonly Goiás: "GO";
+    readonly Maranhão: "MA";
+    readonly MinasGerais: "MG";
+    readonly MatoGrossodoSul: "MS";
+    readonly MatoGrosso: "MT";
+    readonly Pará: "PA";
+    readonly Paraíba: "PB";
+    readonly Pernambuco: "PE";
+    readonly Piauí: "PI";
+    readonly Paraná: "PR";
+    readonly RiodeJaneiro: "RJ";
+    readonly RioGrandedoNorte: "RN";
+    readonly Rondônia: "RO";
+    readonly Roraima: "RR";
+    readonly RioGrandedoSul: "RS";
+    readonly SantaCatarina: "SC";
+    readonly Sergipe: "SE";
+    readonly SãoPaulo: "SP";
+    readonly Tocantins: "TO";
+};
+export type StateCodeUS = (typeof StateCodesUS)[keyof typeof StateCodesUS];
+export declare const StateCodesUS: {
+    readonly Alabama: "AL";
+    readonly Alaska: "AK";
+    readonly Arizona: "AZ";
+    readonly Arkansas: "AR";
+    readonly California: "CA";
+    readonly Colorado: "CO";
+    readonly Connecticut: "CT";
+    readonly Delaware: "DE";
+    readonly DistrictOfColumbia: "DC";
+    readonly Florida: "FL";
+    readonly Georgia: "GA";
+    readonly Hawaii: "HI";
+    readonly Idaho: "ID";
+    readonly Illinois: "IL";
+    readonly Indiana: "IN";
+    readonly Iowa: "IA";
+    readonly Kansas: "KS";
+    readonly Kentucky: "KY";
+    readonly Louisiana: "LA";
+    readonly Maine: "ME";
+    readonly Maryland: "MD";
+    readonly Massachusetts: "MA";
+    readonly Michigan: "MI";
+    readonly Minnesota: "MN";
+    readonly Mississippi: "MS";
+    readonly Missouri: "MO";
+    readonly Montana: "MT";
+    readonly Nebraska: "NE";
+    readonly Nevada: "NV";
+    readonly NewHampshire: "NH";
+    readonly NewJersey: "NJ";
+    readonly NewMexico: "NM";
+    readonly NewYork: "NY";
+    readonly NorthCarolina: "NC";
+    readonly NorthDakota: "ND";
+    readonly Ohio: "OH";
+    readonly Oklahoma: "OK";
+    readonly Oregon: "OR";
+    readonly Pennsylvania: "PA";
+    readonly RhodeIsland: "RI";
+    readonly SouthCarolina: "SC";
+    readonly SouthDakota: "SD";
+    readonly Tennessee: "TN";
+    readonly Texas: "TX";
+    readonly Utah: "UT";
+    readonly Vermont: "VT";
+    readonly Virginia: "VA";
+    readonly Washington: "WA";
+    readonly WestVirginia: "WV";
+    readonly Wisconsin: "WI";
+    readonly Wyoming: "WY";
+};
 export {};

package/dist/types/types/errors/entity-problems.d.ts

@@ -1,10 +1,10 @@
-import type { EntityType } from '../../core/models/api/entity-type';
+import type { EntityTypes } 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 = {
+export type FormValidationErrors = {
     [fieldName: string]: boolean;
 };
 export type EntityProblems = {
@@ -17,7 +17,6 @@ export type EntityProblems = {
     validationErrors?: {
         [formId: string]: FormValidationErrors;
     };
-    entityType?: LegalEntityType | EntityType.BANK_ACCOUNT;
+    entityType?: LegalEntityType | typeof EntityTypes.BANK_ACCOUNT;
     isReviewRequired?: boolean;
 };
-export {};

package/dist/types/types/form-rules.d.ts

@@ -3,7 +3,7 @@ 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 { TaskType } from '../stores/globalStore/taskTypes';
 import type { AccountHolderOption } from './accountHolder';
 import type { CountryCode } from './datasets/country-code';
 import type { EntityProblems } from './errors/entity-problems';
@@ -11,7 +11,7 @@ export interface FormRulesParams<TLDS extends TopLevelDataSchema> {
     matchingScenario?: Scenario[];
     data: TLDS;
     country: CountryCode;
-    taskType: TaskTypes;
+    taskType: TaskType;
     isExperimentEnabled?: (experiment: ExperimentName) => boolean;
     requiredFields?: Partial<AccountFormatRequirements>;
     rootLegalEntity?: ExistingLegalEntity;

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

@@ -1,4 +1,4 @@
-import { TaskTypes } from '../../stores/globalStore/taskTypes';
+import { type TaskType } from '../../stores/globalStore/taskTypes';
 import type { EntityProblems } from '../../types/errors/entity-problems';
 import type { ValidationError } from '../validationError';
 /**
@@ -7,6 +7,6 @@ import type { ValidationError } from '../validationError';
  * @param dropinTask - the dropin page we are processing validations for.
  * @param keyMappings - the actual keymappings, for non-task components
  */
-export declare const processValidationErrors: <T extends string>(validationError: ValidationError, dropinTask?: TaskTypes, keyMappings?: {
+export declare const processValidationErrors: <T extends string>(validationError: ValidationError, dropinTask?: TaskType, keyMappings?: {
     [key: string]: T | undefined;
 }) => EntityProblems["validationErrors"];

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

@@ -1,6 +1,6 @@
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
 import type { Translatable } from '../../types';
-import { TaskTypes } from '../stores/globalStore/taskTypes';
+import { type TaskType } from '../stores/globalStore/taskTypes';
 import type { CountryCode } from '../types/datasets/country-code';
 import type { PersonalDetailsSchema } from '../components/Individual/forms/Individual/PersonalDetails/types';
 /**
@@ -36,7 +36,7 @@ export declare const isPersonUnderAge: (birthDate?: string, country?: CountryCod
  * @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;
+export declare const isLegalRepresentativeNeeded: (birthDate?: string, country?: CountryCode, taskType?: TaskType) => boolean;
 /**
  * Generates a warning message if a legal representative is required.
  * @param data - The personalDetails data.
@@ -45,7 +45,7 @@ export declare const isLegalRepresentativeNeeded: (birthDate?: string, country?:
  */
 export declare const getLegalRepresentativeWarningMessage: ({ data, taskType, }: {
     data: PersonalDetailsSchema | undefined;
-    taskType: TaskTypes;
+    taskType: TaskType;
 }) => TranslatableAlertProps | undefined;
 /**
  * Checks if an age is within a given range.

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

@@ -1,5 +1,6 @@
 import type { TranslationKey } from '../../types';
-import { DecisionMakerType } from '../core/models/api/decision-maker-type';
+import { type DecisionMakerType } from '../core/models/api/decision-maker-type';
+import { type Scenario } from '../core/models/api/get-scenarios';
 /**
  *
  * 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.
@@ -46,8 +47,8 @@ export interface DecisionMakerRequirement {
     min: number;
     max: number;
 }
-export declare const getDecisionMakerRequirements: (country: string | undefined) => readonly DecisionMakerRequirement[];
-export declare function getAvailableDecisionMakerRoleTypes(country: string): {
+export declare const getDecisionMakerRequirements: (country: string | undefined, matchingScenarios?: Scenario[]) => readonly DecisionMakerRequirement[];
+export declare function getAvailableDecisionMakerRoleTypes(country: string, matchingScenarios?: Scenario[]): {
     roleType: DecisionMakerType;
     min: number;
     max: number;

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

@@ -1,10 +1,11 @@
-import { DecisionMakerType } from '../core/models/api/decision-maker-type';
+import { type DecisionMakerType } from '../core/models/api/decision-maker-type';
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
 import type { LegalEntityAssociation } from '../core/models/api/legal-entity-association';
-import { TaskTypes } from '../stores/globalStore/taskTypes';
+import type { Scenario } from '../core/models/api/get-scenarios';
+import { type TaskType } from '../stores/globalStore/taskTypes';
 export declare const getOwnDecisionMakers: (rootLegalEntity: ExistingLegalEntity) => LegalEntityAssociation[];
 export declare const getDecisionMakers: (rootLegalEntity: ExistingLegalEntity, companyLegalEntityId: string) => LegalEntityAssociation[];
 export declare const getOwnSignatories: (rootLegalEntity: ExistingLegalEntity) => LegalEntityAssociation[];
 export declare const getOwnDecisionMakersLegalEntityIds: (rootLegalEntity: ExistingLegalEntity) => string[];
-export declare const getAllowedDecisionMakerRoles: (rootLegalEntity: ExistingLegalEntity, taskType: TaskTypes) => DecisionMakerType[];
+export declare const getAllowedDecisionMakerRoles: (rootLegalEntity: ExistingLegalEntity, taskType: TaskType, scenarios?: Scenario[]) => DecisionMakerType[];
 export declare const hasMinRequiredDecisionMakerCount: (rootLegalEntity: ExistingLegalEntity) => boolean;

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

@@ -1,10 +1,9 @@
 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 { TaskTypes } from '../stores/globalStore/taskTypes';
+import { type LegalEntityType } from '../core/models/api/legal-entity-type';
+import { type TaskType } from '../stores/globalStore/taskTypes';
 import type { AccountHolderOption } from '../types/accountHolder';
 import type { CountryCode } from '../types/datasets/country-code';
-import { CountryCodes } 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';
@@ -23,9 +22,9 @@ export declare const hasSolePropInLegalEntity: (rootLegalEntity: ExistingLegalEn
 export declare const getOwnSolePropProblems: (rootLegalEntity: ExistingLegalEntity, capabilityProblems: CapabilityProblems) => EntityProblems | undefined;
 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 filterOutUnwantedAssociationsIfRootLE: (taskType: TaskType, legalEntity: ExistingLegalEntity | undefined, accountHolder: AccountHolderOption | undefined) => LegalEntityAssociation[] | undefined;
 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;