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

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

@@ -0,0 +1,31 @@
+import type { JSX } from 'preact';
+import type { NestedErrorState, NestedValidState } from '../useMultiForm/types';
+import type { CountryCode } from '../../types/datasets/country-code';
+import type { FormUtils } from '../../utils/formUtils';
+interface UseLegalCompanyNameFieldProps<FormSchema> {
+    data: FormSchema;
+    valid: NestedValidState<FormSchema>;
+    errors: NestedErrorState<FormSchema>;
+    fieldProblems: NestedValidState<FormSchema>;
+    country: CountryCode;
+    formUtils: FormUtils<FormSchema>;
+    fieldOptions: {
+        [key in keyof FormSchema]: {
+            onInput: (e: any) => void;
+            onBlur: (e: FocusEvent) => void;
+        };
+    };
+}
+export declare function useLegalCompanyNameField<FormSchema>({ data, valid, errors, fieldProblems, country, formUtils, fieldOptions, }: UseLegalCompanyNameFieldProps<FormSchema>): ({
+    name: string;
+    value: string;
+    readonly: boolean;
+    onInput: (e: any) => void;
+    onBlur: (e: FocusEvent) => void;
+    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];
+    onKeyDown: (e: JSX.TargetedKeyboardEvent<HTMLInputElement>) => void;
+} | undefined)[];
+export {};

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

@@ -20,51 +20,50 @@ export interface FormState<InnerFormSchema> {
     dataStoreId?: string;
     local?: FormState<InnerFormSchema> | Partial<FormState<InnerFormSchema>>;
 }
+export type FormName<T> = keyof {
+    [InnerFormName in keyof T]: T[InnerFormName];
+};
+export type NestedSchema<T> = T[keyof T];
 export interface Form<T> extends MultiFormState<T> {
-    setData: (key: keyof NestedSchema<T>, value: FieldValue<NestedSchema<T>>, formName: FormName<T>) => void;
+    setData<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: FieldValue<NestedSchema<T>>, formName: InnerFormName): void;
     setFormData: <FN extends FormName<T>>(formName: FN, formData: T[FN]) => void;
-    setValid: (key: keyof NestedSchema<T>, value: boolean, formName: FormName<T>) => void;
-    setErrors: (key: keyof NestedSchema<T>, value: ValidationRuleResult | null, formName: FormName<T>) => void;
+    setValid<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: boolean, formName: InnerFormName): void;
+    setErrors<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], value: ValidationRuleResult | null, formName: InnerFormName): void;
     handleChangeFor<InnerFormName extends keyof T>(key: keyof Required<T>[InnerFormName], formName: InnerFormName, mode?: ValidatorMode): (e: any) => void;
-    triggerValidation: (formName: FormName<T>, selectedSchema?: (keyof NestedSchema<T>)[]) => Promise<boolean>;
+    triggerValidation<InnerFormName extends keyof T>(formName: InnerFormName, selectedSchema?: Array<keyof Required<T>[InnerFormName]>): Promise<boolean>;
     resetToDefaultData: () => void;
     defaultData?: T;
 }
-export type FormName<T> = keyof {
-    [InnerFormName in keyof T]: T[InnerFormName];
+export type NestedErrorState<InnerFormSchema> = {
+    [FieldName in keyof InnerFormSchema]: ValidationRuleResult | null;
+};
+export type NestedValidState<InnerFormSchema> = {
+    [FieldName in keyof InnerFormSchema]: boolean;
+};
+export type MultiFormErrorState<TopLevelSchema> = {
+    [InnerFormName in keyof TopLevelSchema]: NestedErrorState<TopLevelSchema[InnerFormName]>;
+};
+export type MultiFormValidState<TopLevelSchema> = {
+    [InnerFormName in keyof TopLevelSchema]: NestedValidState<TopLevelSchema[InnerFormName]>;
 };
-export type NestedSchema<T> = T[keyof T];
 export type MultiFormState<T> = {
-    requiredFields?: {
-        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
-    };
     data: T;
-    errors: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: ValidationRuleResult | null;
-        };
-    };
-    asyncErrors: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: ValidationRuleResult | null;
-        };
-    };
-    valid: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: boolean;
-        };
-    };
-    fieldProblems: {
-        [InnerFormName in keyof T]: {
-            [FieldName in keyof T[InnerFormName]]: boolean;
-        };
+    errors: MultiFormErrorState<T>;
+    asyncErrors: MultiFormErrorState<T>;
+    valid: MultiFormValidState<T>;
+    fieldProblems: MultiFormValidState<T>;
+    allFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
-    obscuredFields?: {
+    requiredFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
     optionalFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
     trustedFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
@@ -77,11 +76,6 @@ export type MultiFormState<T> = {
     defaultData?: T;
 };
 export interface MultiFormOptions<T> {
-    requiredFields?: {
-        [InnerFormName in keyof T]: (keyof Required<T[InnerFormName]>)[];
-    } | ((data: T | undefined) => {
-        [InnerFormName in keyof T]: (keyof T[InnerFormName])[];
-    });
     defaultData?: T;
     rules?: {
         [InnerFormName in keyof T]: ValidatorRules<T[InnerFormName]>;
@@ -101,12 +95,20 @@ export interface MultiFormOptions<T> {
             [FieldName in keyof T[InnerFormName]]: boolean;
         };
     };
-    obscuredFields?: {
+    allFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
+    requiredFields?: {
+        [InnerFormName in keyof T]: (keyof Required<T[InnerFormName]>)[];
+    } | ((data: T | undefined) => {
+        [InnerFormName in keyof T]: (keyof T[InnerFormName])[];
+    });
     optionalFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };
+    obscuredFields?: {
+        [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
+    };
     trustedFields?: {
         [InnerFormName in keyof T]: Array<keyof T[InnerFormName]>;
     };

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

@@ -1,2 +1,2 @@
 import type { Form, MultiFormOptions } from './types';
-export declare function useMultiForm<FormSchema>({ requiredFields, defaultData, rules, asyncRules, fieldProblems, obscuredFields, optionalFields, trustedFields, formatters, }: MultiFormOptions<FormSchema>): Form<FormSchema>;
+export declare function useMultiForm<FormSchema>({ defaultData, rules, asyncRules, fieldProblems, allFields, requiredFields, obscuredFields, optionalFields, trustedFields, formatters, }: MultiFormOptions<FormSchema>): Form<FormSchema>;

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/Language.d.ts

@@ -3,7 +3,6 @@ import type { GetTranslationOptions } from './utils';
 export declare class Language {
     private readonly supportedLocales;
     readonly translations: Translations;
-    readonly languageCode: string;
     readonly locale: string;
     constructor({ locale, translations, allowedLocales, }: {
         locale?: string;
@@ -13,12 +12,7 @@ export declare class Language {
     /**
      * Returns a translated string from a key in the current {@link Language.locale}
      * @returns Translated string in the user's locale
+     * @deprecated we now have i18next for i18n, check out {@link /src/language/README.md} for more details and examples
      */
     get(translatable: Translatable, translationOptions?: GetTranslationOptions): string;
-    /**
-     * Returns a localized string for a date
-     * @param date - Date to be localized
-     * @param options - Options for {@link Intl.DateTimeFormatOptions}
-     */
-    date(date: string, options?: Intl.DateTimeFormatOptions): string;
 }

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

@@ -0,0 +1,2 @@
+import i18n from 'i18next';
+export default i18n;

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

@@ -1,3 +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;
@@ -7,3 +9,6 @@ export type TranslationObject = {
     values: Record<string, string>;
 };
 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/language/utils.d.ts

@@ -1,5 +1,6 @@
+import type { TFunction } from 'i18next';
 import type { CountryCode } from '../types/datasets/country-code';
-import type { TranslationItem, TranslationKey, Translations } from './types';
+import type { Translatable, TranslationItem, TranslationKey, Translations } from './types';
 /**
  * Matches a string with one of the locales
 
@@ -31,7 +32,6 @@ export interface GetTranslationOptions {
  * Returns a translation string by key
  */
 export declare const getTranslationByKey: (translations: Translations, key: TranslationKey, options?: GetTranslationOptions) => TranslationItem | null;
-export declare const getTranslationKeysByPrefix: (translations: Translations, keyPrefix: string) => TranslationKey[];
 /**
  * Returns a LanguageCode from locale
  * @param locale - The locale the user wants to use
@@ -40,3 +40,12 @@ export declare const getTranslationKeysByPrefix: (translations: Translations, ke
  * // returns 'en'
  */
 export declare const getLanguageCode: (locale: string) => string;
+/**
+ * A helper function to translate a `Translatable` type, which can be either a simple string key
+ * or an object with a key and values for interpolation. It uses the provided `i18next` `t` function.
+ *
+ * @param t - The `i18next` translation function.
+ * @param translatable - The string or object to translate.
+ * @returns The translated string.
+ */
+export declare const translateStringOrObject: (t: TFunction, translatable: Translatable) => string;

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";
+};