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

package/dist/types/core/models/api/get-scenarios.d.ts

@@ -2,21 +2,21 @@
  * @description These are the available scenarios matching the API
  * kycexternalapi/src/main/java/com/adyen/services/kycexternalapi/entity/Scenario.java
  */
-export declare const enum Scenarios {
-    L = "L",
-    L0 = "L0",
-    L1 = "L1",
-    L1_ID = "L1_ID",
-    L1_IDO = "L1_IDO",
-    L1_NAT = "L1_NAT",
-    L1_IDDOC = "L1_IDDOC",
-    L2 = "L2",
-    L_REGDOC = "L_REGDOC",
-    L_TAXDOC = "L_TAXDOC",
-    L_PROOFOFADDRESS = "L_PROOFOFADDRESS",
-    L_PH = "L_PH",
-    L_MOTION = "L_MOTION",
-    L_TAXINFO = "L_TAXINFO",
-    L_BAFIN = "L_BAFIN"
-}
-export type Scenario = `${Scenarios}`;
+export declare const Scenarios: {
+    readonly L: "L";
+    readonly L0: "L0";
+    readonly L1: "L1";
+    readonly L1_ID: "L1_ID";
+    readonly L1_IDO: "L1_IDO";
+    readonly L1_NAT: "L1_NAT";
+    readonly L1_IDDOC: "L1_IDDOC";
+    readonly L2: "L2";
+    readonly L_REGDOC: "L_REGDOC";
+    readonly L_TAXDOC: "L_TAXDOC";
+    readonly L_PROOFOFADDRESS: "L_PROOFOFADDRESS";
+    readonly L_PH: "L_PH";
+    readonly L_MOTION: "L_MOTION";
+    readonly L_TAXINFO: "L_TAXINFO";
+    readonly L_BAFIN: "L_BAFIN";
+};
+export type Scenario = (typeof Scenarios)[keyof typeof Scenarios];

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

@@ -13,6 +13,7 @@ interface NameLocalization {
 export interface Individual {
     birthData?: {
         dateOfBirth: string;
+        placeOfBirth?: string;
     };
     email?: string;
     identificationData?: {

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

@@ -2,10 +2,10 @@ import type { GuidanceQuestionValue } from '../../../components/Individual/forms
 import type { SettlorExemptionReason } from '../../../components/Trust/forms/TrustRoleAndEntityType/types';
 import type { MixpanelProperty } from '../../user-events';
 import type { DecisionMakerType } from './decision-maker-type';
-import type { LegalEntityType } from './legal-entity-type';
+import type { LegalEntityType, LegalEntityTypes } from './legal-entity-type';
 import type { TrustMemberType } from './trust-member-type';
 import type { UnincorporatedPartnershipMemberType } from './unincorporated-partnership';
-export type LegalEntityAssociationType = DecisionMakerType | TrustMemberType | LegalEntityType.TRUST | LegalEntityType.SOLE_PROPRIETORSHIP | LegalEntityType.UNINCORPORATED_PARTNERSHIP | UnincorporatedPartnershipMemberType | 'legalRepresentative' | 'immediateParentCompany' | 'ultimateParentCompany';
+export type LegalEntityAssociationType = DecisionMakerType | TrustMemberType | typeof LegalEntityTypes.TRUST | typeof LegalEntityTypes.SOLE_PROPRIETORSHIP | typeof LegalEntityTypes.UNINCORPORATED_PARTNERSHIP | UnincorporatedPartnershipMemberType | 'legalRepresentative' | 'immediateParentCompany' | 'ultimateParentCompany';
 export type LegalRepresentativeRelationshipType = 'parent' | 'guardian';
 export interface LegalEntityAssociation {
     [key: string]: MixpanelProperty;

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

@@ -1,7 +1,8 @@
-export declare enum LegalEntityType {
-    INDIVIDUAL = "individual",
-    ORGANIZATION = "organization",
-    TRUST = "trust",
-    SOLE_PROPRIETORSHIP = "soleProprietorship",
-    UNINCORPORATED_PARTNERSHIP = "unincorporatedPartnership"
-}
+export type LegalEntityType = (typeof LegalEntityTypes)[keyof typeof LegalEntityTypes];
+export declare const LegalEntityTypes: {
+    readonly INDIVIDUAL: "individual";
+    readonly ORGANIZATION: "organization";
+    readonly TRUST: "trust";
+    readonly SOLE_PROPRIETORSHIP: "soleProprietorship";
+    readonly UNINCORPORATED_PARTNERSHIP: "unincorporatedPartnership";
+};

package/dist/types/core/models/api/trust-member-type.d.ts

@@ -1,8 +1,8 @@
-export declare enum TrustMemberTypes {
-    DEFINED_BENEFICIARY = "definedBeneficiary",
-    UNDEFINED_BENEFICIARY = "undefinedBeneficiary",
-    PROTECTOR = "protector",
-    TRUSTEE = "secondaryTrustee",
-    SETTLOR = "settlor"
-}
-export type TrustMemberType = `${TrustMemberTypes}`;
+export declare const TrustMemberTypes: {
+    readonly DEFINED_BENEFICIARY: "definedBeneficiary";
+    readonly UNDEFINED_BENEFICIARY: "undefinedBeneficiary";
+    readonly PROTECTOR: "protector";
+    readonly TRUSTEE: "secondaryTrustee";
+    readonly SETTLOR: "settlor";
+};
+export type TrustMemberType = (typeof TrustMemberTypes)[keyof typeof TrustMemberTypes];

package/dist/types/core/models/api/trusted-fields-provider.d.ts

@@ -1,4 +1,5 @@
-export declare enum TrustedFieldsProvider {
-    SINGPASS = "singpass",
-    KOMPANY = "kompany"
-}
+export type TrustedFieldsProvider = (typeof TrustedFieldsProviders)[keyof typeof TrustedFieldsProviders];
+export declare const TrustedFieldsProviders: {
+    readonly SINGPASS: "singpass";
+    readonly KOMPANY: "kompany";
+};

package/dist/types/core/models/api/unincorporated-partnership.d.ts

@@ -2,9 +2,9 @@ import type { LegalArrangement } from './legal-arrangement';
 export type UnincorporatedPartnership = LegalArrangement & {
     type?: 'generalPartnership';
 };
-export declare enum UnincorporatedPartnershipMemberTypes {
-    SECONDARY_PARTNER = "secondaryPartner",
-    OWNER = "uboThroughOwnership",
-    CONTROLLING_PERSON = "uboThroughControl"
-}
-export type UnincorporatedPartnershipMemberType = `${UnincorporatedPartnershipMemberTypes}`;
+export declare const UnincorporatedPartnershipMemberTypes: {
+    readonly SECONDARY_PARTNER: "secondaryPartner";
+    readonly OWNER: "uboThroughOwnership";
+    readonly CONTROLLING_PERSON: "uboThroughControl";
+};
+export type UnincorporatedPartnershipMemberType = (typeof UnincorporatedPartnershipMemberTypes)[keyof typeof UnincorporatedPartnershipMemberTypes];

package/dist/types/core/models/api/verification-error.d.ts

@@ -1,13 +1,14 @@
 import type { ErrorCode } from '../../../types/errors/error-message';
 import type { CapabilityName } from './capability';
 import type { RemediatingAction } from './remediating-action';
-export declare enum VerificationErrorType {
-    DATA_MISSING = "dataMissing",
-    INVALID_INPUT = "invalidInput",
-    PENDING_STATUS = "pendingStatus",
-    DATA_REVIEW = "dataReview",
-    REJECTED = "rejected"
-}
+export type VerificationErrorType = (typeof VerificationErrorTypes)[keyof typeof VerificationErrorTypes];
+export declare const VerificationErrorTypes: {
+    readonly DATA_MISSING: "dataMissing";
+    readonly INVALID_INPUT: "invalidInput";
+    readonly PENDING_STATUS: "pendingStatus";
+    readonly DATA_REVIEW: "dataReview";
+    readonly REJECTED: "rejected";
+};
 export interface VerificationError {
     capabilities?: CapabilityName[];
     code: ErrorCode;

package/dist/types/core/models/api/verification-status.d.ts

@@ -1,6 +1,7 @@
-export declare enum VerificationStatus {
-    VALID = "valid",
-    PENDING = "pending",
-    INVALID = "invalid",
-    REJECTED = "rejected"
-}
+export type VerificationStatus = (typeof VerificationStatuses)[keyof typeof VerificationStatuses];
+export declare const VerificationStatuses: {
+    readonly VALID: "valid";
+    readonly PENDING: "pending";
+    readonly INVALID: "invalid";
+    readonly REJECTED: "rejected";
+};

package/dist/types/core/models/api/view-verification-status.d.ts

@@ -1,10 +1,11 @@
-export declare enum OnboardingStatus {
-    AWAITING_DATA = "AWAITING_DATA",
-    IN_REVIEW = "IN_REVIEW",
-    UNSUCCESSFUL = "UNSUCCESSFUL",
-    REJECTED = "REJECTED",// final state - no status changes further
-    VERIFIED = "VERIFIED"
-}
+export type OnboardingStatus = (typeof OnboardingStatuses)[keyof typeof OnboardingStatuses];
+export declare const OnboardingStatuses: {
+    readonly AWAITING_DATA: "AWAITING_DATA";
+    readonly IN_REVIEW: "IN_REVIEW";
+    readonly UNSUCCESSFUL: "UNSUCCESSFUL";
+    readonly REJECTED: "REJECTED";
+    readonly VERIFIED: "VERIFIED";
+};
 /** @deprecated - rely on contract */
 export interface OnboardingLinkConfig {
     locale: string;

package/dist/types/hooks/introduction/useIntroductionScreens.d.ts

@@ -1,8 +1,8 @@
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
-import { IntroductionScreens } from '../../components/Shared/Introduction/types';
-import { TaskTypes } from '../../stores/globalStore/taskTypes';
+import { type IntroductionScreen } from '../../components/Shared/Introduction/types';
+import { type TaskType } from '../../stores/globalStore/taskTypes';
 export interface UseIntroductionScreensProps {
     legalEntity: ExistingLegalEntity;
-    tasks: TaskTypes[];
+    tasks: TaskType[];
 }
-export declare const useIntroductionScreens: ({ legalEntity, tasks }: UseIntroductionScreensProps) => IntroductionScreens[] | undefined;
+export declare const useIntroductionScreens: ({ legalEntity, tasks }: UseIntroductionScreensProps) => IntroductionScreen[] | undefined;

package/dist/types/hooks/singpass/useSingpassMyInfoLogin.d.ts

@@ -2,12 +2,13 @@ import type { Translatable } from '../../../types';
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
 import type { UniqueEntityAssociation } from '../../components/Shared/EntityAssociation/types';
 import type { AccountHolderOption } from '../../types/accountHolder';
-declare enum SingpassMyInfoLoginActionType {
-    LOADING = "LOADING",
-    SUCCESS = "SUCCESS",
-    FAILURE = "FAILURE",
-    RESET = "RESET"
-}
+export type SingpassMyInfoLoginActionType = (typeof SingpassMyInfoLoginActionTypes)[keyof typeof SingpassMyInfoLoginActionTypes];
+declare const SingpassMyInfoLoginActionTypes: {
+    readonly LOADING: "LOADING";
+    readonly SUCCESS: "SUCCESS";
+    readonly FAILURE: "FAILURE";
+    readonly RESET: "RESET";
+};
 interface SingpassMyInfoLoginAction {
     type: SingpassMyInfoLoginActionType;
     isLoading: boolean;

package/dist/types/hooks/useBusinessSetup.d.ts

@@ -1,13 +1,14 @@
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
 import type { AccountHolderOption } from '../types/accountHolder';
-export declare enum BusinessType {
-    INDIVIDUAL = "individual",
-    COMPANY = "company",
-    INCORPORATED_PARTNERSHIP = "partnershipIncorporated",
-    UNINCORPORATED_PARTNERSHIP = "partnershipUnincorporated",
-    INDIVIDUAL_TRUSTEE = "individualTrustee",
-    COMPANY_TRUSTEE = "companyTrustee",
-    SOLE_PROPRIETORSHIP = "soleProprietorship",
-    INCORPORATE_ASSOCIATION = "associationIncorporated"
-}
+export type BusinessType = (typeof BusinessTypes)[keyof typeof BusinessTypes];
+export declare const BusinessTypes: {
+    readonly INDIVIDUAL: "individual";
+    readonly COMPANY: "company";
+    readonly INCORPORATED_PARTNERSHIP: "partnershipIncorporated";
+    readonly UNINCORPORATED_PARTNERSHIP: "partnershipUnincorporated";
+    readonly INDIVIDUAL_TRUSTEE: "individualTrustee";
+    readonly COMPANY_TRUSTEE: "companyTrustee";
+    readonly SOLE_PROPRIETORSHIP: "soleProprietorship";
+    readonly INCORPORATE_ASSOCIATION: "associationIncorporated";
+};
 export declare const useBusinessSetup: (legalEntityResponse: ExistingLegalEntity) => BusinessType | AccountHolderOption | undefined;

package/dist/types/hooks/useDataMissingRemediations.d.ts

@@ -1,11 +1,11 @@
-import { TaskTypes } from '../stores/globalStore/taskTypes';
+import { type TaskType } from '../stores/globalStore/taskTypes';
 import type { CapabilityProblems } from '../types/errors/capability-problems';
 interface UseDataMissingRemediationsProps {
     legalEntityId: string;
     problems: CapabilityProblems;
 }
 interface DataMissingRemediations {
-    remediationMessages: Partial<Record<TaskTypes, string | undefined>>;
+    remediationMessages: Partial<Record<TaskType, string | undefined>>;
 }
 /**
  * @description A hook that parses a legal entities capability problems and maps its verification error codes to task specific remediation messages

package/dist/types/hooks/useFormComposer.d.ts

@@ -5,7 +5,7 @@ import type { EntityProblems } from '../types/errors/entity-problems';
 import type { FormModelWithValidity } from '../types/form';
 import type { Form } from './useMultiForm/types';
 export interface FormComposer {
-    handleNextClick(): void;
+    handleNextClick(updatedForms?: FormModelWithValidity[]): void;
     handleBackClick?(): void;
     gotoFormByFormIndex(index: number): void;
     activeForm: FormModelWithValidity;

package/dist/types/hooks/useLegalCompanyNameField/useLegalCompanyNameField.d.ts

@@ -1,9 +1,12 @@
 import type { JSX } from 'preact';
-import type { Form } from '../useForm/types';
+import type { NestedErrorState, NestedValidState } from '../useMultiForm/types';
 import type { CountryCode } from '../../types/datasets/country-code';
 import type { FormUtils } from '../../utils/formUtils';
-interface UseLegalCompanyNameFieldProps<FormSchema> extends Omit<Form<FormSchema>, 'setFieldProblems' | 'setData' | 'setErrors' | 'setValid' | 'triggerValidation' | 'mergeForm' | 'resetToDefaultData' | 'schema'> {
+interface UseLegalCompanyNameFieldProps<FormSchema> {
     data: FormSchema;
+    valid: NestedValidState<FormSchema>;
+    errors: NestedErrorState<FormSchema>;
+    fieldProblems: NestedValidState<FormSchema>;
     country: CountryCode;
     formUtils: FormUtils<FormSchema>;
     fieldOptions: {
@@ -19,7 +22,7 @@ export declare function useLegalCompanyNameField<FormSchema>({ data, valid, erro
     readonly: boolean;
     onInput: (e: any) => void;
     onBlur: (e: FocusEvent) => void;
-    isValid: Record<keyof FormSchema, boolean>[keyof FormSchema];
+    isValid: NestedValidState<FormSchema>[keyof FormSchema];
     errorMessage: Record<keyof FormSchema, boolean | import("../../../types").Translatable>[keyof FormSchema];
     label: Partial<Record<keyof FormSchema, string>>[keyof FormSchema];
     helper: Partial<Record<keyof FormSchema, string>>[keyof FormSchema];

package/dist/types/hooks/useLegalEntityType.d.ts

@@ -1,5 +1,5 @@
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
-import { LegalEntityType } from '../core/models/api/legal-entity-type';
+import { type LegalEntityType } from '../core/models/api/legal-entity-type';
 export interface UseLegalEntityTypeProps {
     legalEntity: ExistingLegalEntity;
 }

package/dist/types/hooks/useMultiForm/types.d.ts

@@ -58,10 +58,10 @@ export type MultiFormState<T> = {
     requiredFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
-    obscuredFields?: {
+    optionalFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
-    optionalFields?: {
+    obscuredFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
     trustedFields?: {

package/dist/types/hooks/useScenarioConfiguration.d.ts

@@ -5,13 +5,13 @@ import type { LoadingStatus } from '../components/ui/atoms/LoaderWrapper/constan
 import type { TopLevelDataSchema } from '../context/StateContext/types';
 import type { AccountFormatRequirements, PayoutAccountFormats } from '../datasets/generators/getAccountFormatForCountry';
 import type { LegalEntityType } from '../core/models/api/legal-entity-type';
-import type { TaskTypes } from '../stores/globalStore/taskTypes';
+import type { TaskType } from '../stores/globalStore/taskTypes';
 import type { CountryCode } from '../types/datasets/country-code';
 import type { FormConfiguration } from '../types/form-configuration';
 import type { BankAccountFormatType } from '../components/BankAccount/fields/BankAccountFormat/types';
 export type ParseConfiguration<TLDS extends TopLevelDataSchema> = (configuration: {
     scenarios: Scenario[];
-    taskList?: TaskTypes[];
+    taskList?: TaskType[];
     provider?: BankVerificationVendor;
     bankVerificationProviders?: Partial<Record<CountryCode, string>>;
     requiredFields: AccountFormatRequirements | undefined;

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

@@ -1,4 +1,5 @@
 import type introductionKeys from '#shared/language/introduction/en-US.json';
+import type bankingKeys from '../components/BankAccount/language/en-US.json';
 import type translations from './locales/en-US.json';
 export type TranslationKey = keyof typeof translations;
 export type TranslationItem = string;
@@ -10,3 +11,4 @@ export type TranslationObject = {
 export type Translatable = TranslationKey | TranslationObject;
 export type CommonKey = keyof typeof translations;
 export type IntroductionKey = keyof typeof introductionKeys;
+export type BankingKey = keyof typeof bankingKeys;

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

@@ -6,7 +6,7 @@ import type { CapabilityProblems } from '../../types/errors/capability-problems'
 import type { TrustMember } from '../../components/Trust/tasks/TrustMembers/types';
 import type { TaskIdentifier } from './globalStore';
 import type { TaskStatusWithReason } from './taskStatus';
-import { TaskTypes } from './taskTypes';
+import { type TaskType } from './taskTypes';
 export declare const calculateTaskStatus: ({ taskIdentifier, capabilityProblems, rootLegalEntity, accountHolder, legalRepresentative, trustMembers, transferInstruments, }: {
     taskIdentifier: TaskIdentifier;
     capabilityProblems: CapabilityProblems;
@@ -20,6 +20,6 @@ export declare const calculateTaskStatus: ({ taskIdentifier, capabilityProblems,
  * Splits a {@link TaskIdentifier} (e.g. `PAYOUT_ACCOUNT-abc-123`) into the task type and id
  */
 export declare const splitTaskIdentifier: (taskIdentifier: TaskIdentifier) => {
-    taskType: TaskTypes;
+    taskType: TaskType;
     id?: string;
 };

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

@@ -7,9 +7,9 @@ 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';
-import { TaskTypes } from './taskTypes';
+import { type TaskType } from './taskTypes';
 export declare const determineTaskIdentifiers: ({ taskTypes: receivedTaskTypes, rootLegalEntity, accountHolder, capabilityProblems, trustMembers, transferInstruments, unincorporatedPartnershipMembers, legalRepresentative, }: {
-    taskTypes: TaskTypes[];
+    taskTypes: TaskType[];
     rootLegalEntity: ExistingLegalEntity | undefined;
     accountHolder: AccountHolderOption | undefined;
     capabilities: CapabilityName[];

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

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

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

@@ -8,12 +8,12 @@ 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';
-import { TaskStatus } from './taskStatus';
-import type { TaskTypes } from './taskTypes';
-export type TaskIdentifier = `${TaskTypes}` | `${TaskTypes}-${string}`;
+import type { TaskStatus, TaskStatusWithReason } from './taskStatus';
+import { TaskStatuses } from './taskStatus';
+import type { TaskType } from './taskTypes';
+export type TaskIdentifier = TaskType | `${TaskType}-${string}`;
 export interface GlobalStore {
-    taskTypes: ReadonlySignal<TaskTypes[]>;
+    taskTypes: ReadonlySignal<TaskType[]>;
     rootLegalEntity: ReadonlySignal<ExistingLegalEntity>;
     accountHolder: ReadonlySignal<AccountHolderOption | undefined>;
     trustMembers: ReadonlySignal<TrustMember[]>;
@@ -25,7 +25,7 @@ export interface GlobalStore {
     rootLegalEntityCountry: ReadonlySignal<CountryCode>;
     tasks: ReadonlySignal<TaskIdentifier[]>;
     taskStatuses: ReadonlySignal<TaskStatuses>;
-    setTaskTypes(taskTypes: TaskTypes[]): void;
+    setTaskTypes(taskTypes: TaskType[]): void;
     setRootLegalEntity(rootLegalEntity: ExistingLegalEntity): void;
     setAccountHolder(accountHolder: AccountHolderOption | undefined): void;
     setTrustMembers(trustMembers: TrustMember[]): void;
@@ -40,5 +40,5 @@ export declare const createGlobalStore: ({ rootLegalEntity: rootLegalEntityIn, }
 }) => 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 declare const useGetTaskStatus: () => (taskType: TaskType, id?: string) => TaskStatus;
 export {};

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

@@ -1,22 +1,23 @@
 import type { ApiTaskStatus, TaskStatusEntry } from '../../api/taskStatus/taskStatus.types';
-import type { TaskTypes } from '../globalStore/taskTypes';
+import type { TaskType } from '../globalStore/taskTypes';
+export type TaskStatus = (typeof TaskStatuses)[keyof typeof TaskStatuses];
 /**
  * Order of TaskStatus enums are used to define the priority of the statuses
  * while processing the capabilities.
  */
-export declare enum TaskStatus {
-    EMPTY = 0,
-    FINISHED = 1,
-    PROCESSING = 2,
-    DETAILS_REQUIRED = 3,
-    SIGN = 4,
-    DOWNLOAD = 5,
-    ERROR = 6,
-    SIGNED = 7,
-    SUBMIT = 8,
-    REMOVING = 9,
-    UNKNOWN = 10
-}
+export declare const TaskStatuses: {
+    readonly EMPTY: 0;
+    readonly FINISHED: 1;
+    readonly PROCESSING: 2;
+    readonly DETAILS_REQUIRED: 3;
+    readonly SIGN: 4;
+    readonly DOWNLOAD: 5;
+    readonly ERROR: 6;
+    readonly SIGNED: 7;
+    readonly SUBMIT: 8;
+    readonly REMOVING: 9;
+    readonly UNKNOWN: 10;
+};
 type Reason = 'rootLegalEntityIsEmpty' | 'newEntityAlwaysEmpty' | 'legalRepresentativeNeeded' | 'bankAccountNeeded' | 'missingRequiredDecisionMakers' | 'missingRequiredTrustMembers' | 'invalidInputError' | 'dataMissingError' | 'dataReviewNeeded' | 'pendingStatusError' | 'pendingCapabilities' | 'invalidCapabilities' | 'allCapabilitiesValid' | 'noIssuesFound';
 export interface TaskStatusWithReason {
     status: TaskStatus;
@@ -25,14 +26,14 @@ export interface TaskStatusWithReason {
 }
 export interface TaskStatusWithType {
     status: ApiTaskStatus;
-    type: TaskTypes;
+    type: TaskType;
     taskStatusEntries?: TaskStatusEntry[];
 }
 export interface TaskStatusApiResponse {
     statuses: TaskStatusWithType[];
 }
 export type NormalizedTaskStatus = {
-    [key in TaskTypes]?: {
+    [key in TaskType]?: {
         status: TaskStatus;
         taskStatusEntries?: TaskStatusEntry[];
     };

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

@@ -1,35 +1,37 @@
-export declare enum TaskTypes {
-    BUSINESS_TYPE_SELECTION = "BUSINESS_TYPE_SELECTION",
-    INTRODUCTION = "INTRODUCTION",
-    TASKS_OVERVIEW = "TASKS_OVERVIEW",
-    REVIEW = "REVIEW",
-    INDIVIDUAL = "INDIVIDUAL",
-    BUSINESS_DETAILS = "BUSINESS_DETAILS",
-    CUSTOMER_SUPPORT = "CUSTOMER_SUPPORT",
-    PAYOUT = "PAYOUT",
-    PAYIN = "PAYIN",
-    SERVICE_AGREEMENT = "SERVICE_AGREEMENT",
-    PCI_DSS = "PCI_DSS",
-    DECISION_MAKER = "DECISION_MAKER",
-    DECISION_MAKER_OVERVIEW = "DECISION_MAKER_OVERVIEW",
-    TRUST = "TRUST",
-    TRUST_MEMBER = "TRUST_MEMBER",
-    TRUST_MEMBER_OVERVIEW = "TRUST_MEMBER_OVERVIEW",
-    TRUST_MEMBER_INDIVIDUAL = "TRUST_MEMBER_INDIVIDUAL",
-    TRUST_MEMBER_COMPANY = "TRUST_MEMBER_COMPANY",
-    TRUST_MEMBER_ROLE_AND_TYPE = "TRUST_MEMBER_ROLE_AND_TYPE",
-    TRUST_MEMBER_COMPANY_OWNER = "TRUST_MEMBER_COMPANY_OWNER",
-    UNINCORPORATED_PARTNERSHIP = "UNINCORPORATED_PARTNERSHIP",
-    UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW = "UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW",
-    UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL = "UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL",
-    UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY = "UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY",
-    UNINCORPORATED_PARTNERSHIP_MEMBER_ROLE_AND_TYPE = "UNINCORPORATED_PARTNERSHIP_MEMBER_ROLE_AND_TYPE",
-    UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER = "UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER",
-    SOLE_PROPRIETOR_COMPANY = "SOLE_PROPRIETOR_COMPANY",
-    CAPABILITY_REJECTED = "CAPABILITY_REJECTED",
-    SINGPASS_SELECTION = "SINGPASS_SELECTION",
-    LEGAL_REPRESENTATIVE_DETAILS = "LEGAL_REPRESENTATIVE_DETAILS",
-    SOURCE_OF_FUNDS = "SOURCE_OF_FUNDS",
-    BUSINESS_FINANCING = "BUSINESS_FINANCING",
-    TAX_REPORTING = "TAX_REPORTING"
-}
+export type TaskType = (typeof TaskTypes)[keyof typeof TaskTypes];
+export declare const TaskTypes: {
+    readonly BUSINESS_TYPE_SELECTION: "BUSINESS_TYPE_SELECTION";
+    readonly BUSINESS_LINES: "BUSINESS_LINES";
+    readonly INTRODUCTION: "INTRODUCTION";
+    readonly TASKS_OVERVIEW: "TASKS_OVERVIEW";
+    readonly REVIEW: "REVIEW";
+    readonly INDIVIDUAL: "INDIVIDUAL";
+    readonly BUSINESS_DETAILS: "BUSINESS_DETAILS";
+    readonly CUSTOMER_SUPPORT: "CUSTOMER_SUPPORT";
+    readonly PAYOUT: "PAYOUT";
+    readonly PAYIN: "PAYIN";
+    readonly SERVICE_AGREEMENT: "SERVICE_AGREEMENT";
+    readonly PCI_DSS: "PCI_DSS";
+    readonly DECISION_MAKER: "DECISION_MAKER";
+    readonly DECISION_MAKER_OVERVIEW: "DECISION_MAKER_OVERVIEW";
+    readonly TRUST: "TRUST";
+    readonly TRUST_MEMBER: "TRUST_MEMBER";
+    readonly TRUST_MEMBER_OVERVIEW: "TRUST_MEMBER_OVERVIEW";
+    readonly TRUST_MEMBER_INDIVIDUAL: "TRUST_MEMBER_INDIVIDUAL";
+    readonly TRUST_MEMBER_COMPANY: "TRUST_MEMBER_COMPANY";
+    readonly TRUST_MEMBER_ROLE_AND_TYPE: "TRUST_MEMBER_ROLE_AND_TYPE";
+    readonly TRUST_MEMBER_COMPANY_OWNER: "TRUST_MEMBER_COMPANY_OWNER";
+    readonly UNINCORPORATED_PARTNERSHIP: "UNINCORPORATED_PARTNERSHIP";
+    readonly UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW: "UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW";
+    readonly UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL: "UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL";
+    readonly UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY: "UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY";
+    readonly UNINCORPORATED_PARTNERSHIP_MEMBER_ROLE_AND_TYPE: "UNINCORPORATED_PARTNERSHIP_MEMBER_ROLE_AND_TYPE";
+    readonly UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER: "UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER";
+    readonly SOLE_PROPRIETOR_COMPANY: "SOLE_PROPRIETOR_COMPANY";
+    readonly CAPABILITY_REJECTED: "CAPABILITY_REJECTED";
+    readonly SINGPASS_SELECTION: "SINGPASS_SELECTION";
+    readonly LEGAL_REPRESENTATIVE_DETAILS: "LEGAL_REPRESENTATIVE_DETAILS";
+    readonly SOURCE_OF_FUNDS: "SOURCE_OF_FUNDS";
+    readonly BUSINESS_FINANCING: "BUSINESS_FINANCING";
+    readonly TAX_REPORTING: "TAX_REPORTING";
+};