@adyen/kyc-components 4.0.0-compact.1 → 4.0.0

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

@@ -1,6 +1,12 @@
 import type { SupportingEntityCapability } from './supporting-entity-capability';
 import type { VerificationStatus } from './verification-status';
 export type CapabilityName = 'acceptExternalFunding' | 'acceptPspFunding' | 'acceptTransactionInRestrictedCountries' | 'acceptTransactionInRestrictedCountriesCommercial' | 'acceptTransactionInRestrictedCountriesConsumer' | 'acceptTransactionInRestrictedIndustries' | 'acceptTransactionInRestrictedIndustriesCommercial' | 'acceptTransactionInRestrictedIndustriesConsumer' | 'acquiring' | 'atmWithdrawal' | 'atmWithdrawalCommercial' | 'atmWithdrawalConsumer' | 'atmWithdrawalInRestrictedCountries' | 'atmWithdrawalInRestrictedCountriesCommercial' | 'atmWithdrawalInRestrictedCountriesConsumer' | 'authorisedPaymentInstrumentUser' | 'getGrantOffers' | 'issueBankAccount' | 'banking' | 'issueCard' | 'issueCardCommercial' | 'issueCardConsumer' | 'localAcceptance' | 'payout' | 'payoutToTransferInstrument' | 'processing' | 'receiveFromBalanceAccount' | 'receiveFromPlatformPayments' | 'receiveFromThirdParty' | 'receiveFromTransferInstrument' | 'receiveGrants' | 'receivePayments' | 'sendToBalanceAccount' | 'sendToThirdParty' | 'sendToTransferInstrument' | 'thirdPartyFunding' | 'useCard' | 'useCardCommercial' | 'useCardConsumer' | 'useCardInRestrictedCountries' | 'useCardInRestrictedCountriesCommercial' | 'useCardInRestrictedCountriesConsumer' | 'useCardInRestrictedIndustries' | 'useCardInRestrictedIndustriesCommercial' | 'useCardInRestrictedIndustriesConsumer' | 'withdrawFromAtm' | 'withdrawFromAtmCommercial' | 'withdrawFromAtmConsumer' | 'withdrawFromAtmInRestrictedCountries' | 'withdrawFromAtmInRestrictedCountriesCommercial' | 'withdrawFromAtmInRestrictedCountriesConsumer';
+interface Amount {
+    /** @description The type of currency. Must be EUR (or EUR equivalent) */
+    currency?: string;
+    /** @description Total value of amount. Must be >= 0 */
+    value?: number;
+}
 export interface Capability {
     /** @description Indicates whether the capability is allowed. Adyen sets this to **true** if the verification is successful */
     allowed?: boolean;
@@ -20,6 +26,19 @@ export interface Capability {
      * @enum {string}
      */
     requestedLevel?: 'high' | 'low' | 'medium' | 'notApplicable';
+    /** @description The settings that are requested for the legal entity */
+    requestedSettings?: {
+        /** @description The maximum amount a card holder can spend per industry */
+        amountPerIndustry?: Record<string, Amount>;
+        /** @description The number of card holders who can use the card */
+        authorizedCardUsers?: boolean;
+        /** @description The funding source of the card, for example debit */
+        fundingSource?: string[];
+        /** @description The period when the rule conditions apply */
+        interval?: string;
+        /** @description The maximum amount a card holder can withdraw per day */
+        maxAmount?: Amount;
+    };
     /** @description Capability status for transfer instruments associated with legal entity */
     transferInstruments?: readonly SupportingEntityCapability[];
     /**
@@ -37,3 +56,4 @@ export interface Capability {
      */
     verificationStatus?: VerificationStatus;
 }
+export {};

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

@@ -5,7 +5,7 @@ import type { DecisionMakerType } from './decision-maker-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 | typeof LegalEntityTypes.TRUST | typeof LegalEntityTypes.SOLE_PROPRIETORSHIP | typeof LegalEntityTypes.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' | 'originator';
 export type LegalRepresentativeRelationshipType = 'parent' | 'guardian';
 export interface LegalEntityAssociation {
     [key: string]: MixpanelProperty;

package/dist/types/core/models/api/source-of-funds.d.ts

@@ -1,4 +1,5 @@
 import type { CountryCode } from '../../../types/datasets/country-code';
+import type { SalesChannel } from '../../../components/BusinessLines/fields/SalesChannels/types';
 import type { OriginatorTypeUnion } from '../../../components/EFP/tasks/SourceOfFundsDropin/types';
 export interface BusinessLinesType {
     id?: string;
@@ -7,6 +8,10 @@ export interface BusinessLinesType {
     service: BusinessLinesServiceType;
     sourceOfFunds?: SourceOfFundsType;
     webData?: BusinessLinesWebDataType[];
+    webDataExemption?: {
+        reason?: 'noOnlinePresence' | 'notCollectedDuringOnboarding' | undefined;
+    };
+    salesChannels?: SalesChannel[];
 }
 export interface SourceOfFundsType {
     type?: SourceOfFundsCategoryType | 'adyen';

package/dist/types/core/models/api/transfer-instrument.d.ts

@@ -2,6 +2,7 @@ import type { components } from '#api/transferInstruments/transferInstruments.co
 import type { Capability, CapabilityName } from '../../models/api/capability';
 import type { DocumentDetail } from '../../models/api/document';
 import type { CountryCode } from '../../../types/datasets/country-code';
+import type { Currency } from '../../../types/datasets/currency';
 import type { AccountIdentification } from './accountIdentification';
 import type { Problem } from './problem';
 type TransferInstrumentDto = components['schemas']['TransferInstrumentDto'];
@@ -9,6 +10,7 @@ type BankAccountInfoDto = components['schemas']['BankAccountInfoDto'];
 export interface BankAccount extends Omit<BankAccountInfoDto, 'accountIdentification' | 'countryCode'> {
     accountIdentification: AccountIdentification;
     countryCode: CountryCode;
+    preferredCurrencyCode?: Currency;
 }
 export interface TransferInstrument extends Omit<TransferInstrumentDto, 'bankAccount' | 'documentDetails' | 'capabilities' | 'problems'> {
     bankAccount: BankAccount;

package/dist/types/core/process-field-configurations.d.ts

@@ -6,11 +6,13 @@ import type { LegalEntityType } from './models/api/legal-entity-type';
 import type { VerificationError } from './models/api/verification-error';
 import type { Remediation } from '../types/errors/remediation';
 import type { FormList } from '../types/form';
-import type { FormConfiguration, FormConfigurationWithoutRules, PerScenarioFormConfiguration } from '../types/form-configuration';
+import type { FieldSettings, FormConfiguration, FormConfigurationWithoutRules, PerScenarioFormConfiguration } from '../types/form-configuration';
 import type { FormRules } from '../types/form-rules';
 import type { AnyTLDSFieldName } from '../utils/getFieldsWithExistingData';
 export declare const composePerScenarioFormConfigurations: <TLDS extends TopLevelDataSchema>(scenarios: Scenario[] | undefined, configurations: PerScenarioFormConfiguration<TLDS, string>) => FormConfiguration<TLDS, string>;
 export declare const augmentWithCountryConfigs: <OuterFormSchema extends TopLevelDataSchema>(countrySpecificConfig: FormConfigurationWithoutRules<OuterFormSchema> | undefined, baseFormConfig: FormConfiguration<OuterFormSchema, string>) => FormConfiguration<OuterFormSchema, string>;
+export declare const isFieldRequired: (fieldSettings: FieldSettings<string>, customRules: FormRules<string>, reasons?: string[]) => boolean;
+export declare const isFieldOptional: (fieldSettings: FieldSettings<string>, customRules: FormRules<string>, reasons?: string[]) => boolean;
 export type PropsFromConfiguration<OuterFormSchema> = Required<Pick<BaseOuterFormProps<OuterFormSchema>, 'allFields' | 'requiredFields' | 'optionalFields' | 'obscuredFields' | 'trustedFields'>>;
 /**
  * function: getPropsFromScenarios
@@ -65,3 +67,4 @@ customRules, legalEntityType, legalEntityTrustedFields, remediationFieldAsOption
     remediationFieldAsOptional?: boolean;
 }): PropsFromConfiguration<OuterFormSchema> | undefined;
 export declare const makeTLDSFieldName: (formId: string, fieldName: string) => AnyTLDSFieldName;
+export declare const isFieldRequiredToRemediateDataMissingError: (formId: string, field: string, dataMissingErrors: VerificationError[]) => boolean;

package/dist/types/core/user-events.d.ts

@@ -1,4 +1,7 @@
 import type { SetOptional } from 'type-fest';
+import type { CompanyTypesValue } from './models/api/company-types-value';
+import type { DecisionMakerType } from './models/api/decision-maker-type';
+import type { LegalEntityAssociation, LegalEntityAssociationType } from './models/api/legal-entity-association';
 import type { LegalEntityType } from './models/api/legal-entity-type';
 import type { TaskIdentifier } from '../stores/globalStore/globalStore';
 /**
@@ -28,11 +31,15 @@ export type BaseEventProperties = {
     componentName?: string;
     countryCode?: string;
     entityType?: LegalEntityType;
+    associatedLegalEntityType?: LegalEntityType;
+    associatedLegalEntityId?: string;
     locale?: string;
     sdkVersion?: string;
     task?: TaskIdentifier;
     userAgent?: string;
 };
+type RequiredExcept<T, K extends keyof T> = Required<Omit<T, K>> & Partial<Pick<T, K>>;
+type OptionalBaseEventProperties = 'associatedLegalEntityType' | 'associatedLegalEntityId';
 /**
  * Additional event properties
  */
@@ -40,26 +47,36 @@ export interface AdditionalEventProperties {
     actionType: ActionType;
     actionLevel: ActionLevel;
     entityType?: LegalEntityType;
+    task?: string;
     page?: string;
     field?: string;
     returnType?: 'backend' | 'validation' | (string & {});
     returnValue?: string | string[];
+    toPage?: string;
+    content?: string;
     label?: string;
-    /** Testing out JSON key-value pairs mixpanel object */
+    documentType?: string;
+    fileExtention?: string[];
     additionalData?: {
         [key: string]: MixpanelProperty;
     };
-    [key: string]: MixpanelProperty;
     'Experiment name'?: string;
     'Variant name'?: string;
+    legalEntityName?: string;
+    companyStructure?: CompanyTypesValue;
+    usedAdditionalAddress?: boolean;
+    countryOfRegistration?: string;
+    roles?: DecisionMakerType[] | LegalEntityAssociationType[];
+    noOfDecisionMakers?: number;
+    remainingDecisionMakers?: LegalEntityAssociation[];
 }
 /**
  * Name of the tracked event
  * Can be either a custom name or one of the pre-defined values
  */
-export type EventName = 'Clicked button' | 'Clicked accordion' | 'Success' | 'Encountered error' | 'Landed on page' | 'Interacted with form field' | 'Opened modal' | 'Closed modal' | (string & {}) | '$experiment_started';
-export type AnalyticsEventPayload = Required<BaseEventProperties> & AdditionalEventProperties;
-export type EventType = 'add_event' | 'start_event';
+export type EventName = 'Clicked button' | 'Clicked accordion' | 'Success' | 'Encountered error' | 'Landed on page' | 'Interacted with form field' | 'Opened modal' | 'Closed modal' | '$experiment_started';
+export type AnalyticsEventPayload = RequiredExcept<BaseEventProperties, OptionalBaseEventProperties> & AdditionalEventProperties;
+export type EventType = 'add_event';
 export type EventQueueItem = {
     type: EventType;
     name: EventName;
@@ -107,10 +124,6 @@ export declare class UserEvents {
         name: string;
         variant: string;
     }): void;
-    /**
-     * Starts a timer for an event to measure the time it takes for an event to occur. Time is ended when `addEvent` is executed with the same key
-     */
-    startEvent(eventName: EventName): void;
     /**
      * Subscribes a callback to analytics events. It gets called every time
      * one of the above public methods get called, and the event data is passed back as an array.
@@ -140,7 +153,5 @@ export declare class UserEvents {
      */
     unsubscribe(callback: UserEventCallback): void;
 }
-/** @deprecated - use useAnalyticsContext */
-export declare const userEvents: UserEvents;
 export declare const createUserEvents: () => UserEvents;
 export {};

package/dist/types/datasets/generators/getAccountFormatForCountry.d.ts

@@ -9,5 +9,6 @@ export interface AccountFormatRequirements {
 export interface PayoutAccountFormats {
     iban?: AccountFormatRequirements;
     local?: AccountFormatRequirements;
+    numberAndBic?: AccountFormatRequirements;
 }
 export declare const getAccountFormatsForCountry: (country: CountryCode) => Promise<PayoutAccountFormats>;

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

@@ -1,14 +1,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';
-export type SingpassMyInfoLoginActionType = (typeof SingpassMyInfoLoginActionTypes)[keyof typeof SingpassMyInfoLoginActionTypes];
 declare const SingpassMyInfoLoginActionTypes: {
     readonly LOADING: "LOADING";
     readonly SUCCESS: "SUCCESS";
     readonly FAILURE: "FAILURE";
     readonly RESET: "RESET";
 };
+export type SingpassMyInfoLoginActionType = (typeof SingpassMyInfoLoginActionTypes)[keyof typeof SingpassMyInfoLoginActionTypes];
 interface SingpassMyInfoLoginAction {
     type: SingpassMyInfoLoginActionType;
     isLoading: boolean;
@@ -17,10 +16,9 @@ interface SingpassMyInfoLoginAction {
 }
 export type SingpassMyInfoLoginState = Omit<SingpassMyInfoLoginAction, 'type'>;
 interface UseSingpassMyInfoLoginProps {
-    legalEntity?: ExistingLegalEntity;
+    legalEntity: ExistingLegalEntity;
     accountHolder: AccountHolderOption | undefined;
 }
-export declare const getTrustedEntityAssociations: (legalEntityTrustedFields: string[]) => Partial<UniqueEntityAssociation>[];
 export declare const useSingpassMyInfoLogin: ({ legalEntity, accountHolder, }: UseSingpassMyInfoLoginProps) => {
     isEligibleForSingpass: boolean;
     state: SingpassMyInfoLoginState;
@@ -28,7 +26,5 @@ export declare const useSingpassMyInfoLogin: ({ legalEntity, accountHolder, }: U
     handleSingpassMyInfoLoginSuccess: () => void;
     handleSingpassMyInfoLoginFailure: (errorMessage: Translatable) => void;
     handleSingpassMyInfoLoginReset: () => void;
-    trustedFields: Record<string, string[]>;
-    trustedEntityAssociations: Partial<UniqueEntityAssociation>[];
 };
 export {};

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

@@ -0,0 +1,16 @@
+import type { MixpanelProperty, UserEvents } from '../../core/user-events';
+/** @deprecated */
+export interface EmbeddedAnalyticsSessionRequest {
+    sdkVersion: string;
+    componentName: string;
+    userAgent: string;
+    legalEntityId: string;
+    userData?: Record<string, MixpanelProperty>;
+}
+type UseAnalyticsProps = {
+    userEvents: UserEvents;
+    sessionId: string | undefined;
+    sessionData: EmbeddedAnalyticsSessionRequest;
+};
+export declare const useAnalytics: ({ userEvents, sessionId, sessionData }: UseAnalyticsProps) => void;
+export {};

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

@@ -2,6 +2,7 @@ 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';
+import type { ValidatorMode } from '../../utils/validation/types';
 interface UseLegalCompanyNameFieldProps<FormSchema> {
     data: FormSchema;
     valid: NestedValidState<FormSchema>;
@@ -9,23 +10,20 @@ interface UseLegalCompanyNameFieldProps<FormSchema> {
     fieldProblems: NestedValidState<FormSchema>;
     country: CountryCode;
     formUtils: FormUtils<FormSchema>;
-    fieldOptions: {
-        [key in keyof FormSchema]: {
-            onInput: (e: any) => void;
-            onBlur: (e: FocusEvent) => void;
-        };
-    };
+    handleChange: (key: keyof FormSchema, mode?: ValidatorMode) => (e: any) => void;
 }
-export declare function useLegalCompanyNameField<FormSchema>({ data, valid, errors, fieldProblems, country, formUtils, fieldOptions, }: UseLegalCompanyNameFieldProps<FormSchema>): ({
+export declare function useLegalCompanyNameField<FormSchema>({ data, valid, errors, fieldProblems, country, formUtils, handleChange, }: UseLegalCompanyNameFieldProps<FormSchema>): ({
     name: string;
     value: string;
     readonly: boolean;
     onInput: (e: any) => void;
-    onBlur: (e: FocusEvent) => void;
+    onBlur: (e: any) => 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;
+    transformInput: Partial<Record<keyof FormSchema, (value: string) => string>>[keyof FormSchema];
+    transformMode: Partial<Record<keyof FormSchema, ValidatorMode>>[keyof FormSchema];
 } | undefined)[];
 export {};

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

@@ -0,0 +1,25 @@
+import type { CountryCode } from '../types/datasets/country-code';
+import type { FormUtils } from '../utils/formUtils';
+import type { ValidationRuleResult, ValidatorMode } from '../utils/validation/types';
+import type { UboQuestionnaireSchema } from '../components/Individual/forms/IndividualOnfido/UboQuestionnaire/UboQuestionnaire.types';
+interface UseUboQuestionnaireProps {
+    data?: UboQuestionnaireSchema;
+    handleFieldChange?: (fieldName: keyof UboQuestionnaireSchema, mode?: ValidatorMode) => (e: any) => void;
+    openModal: (modalType: keyof UboQuestionnaireSchema) => () => void;
+    country?: CountryCode;
+    formUtils: FormUtils<UboQuestionnaireSchema>;
+    errors?: Partial<Record<keyof UboQuestionnaireSchema, ValidationRuleResult | null>>;
+    fieldValidationErrors?: Partial<Record<keyof UboQuestionnaireSchema, boolean>>;
+}
+export declare const useGuidanceQuestionnaire: ({ data, handleFieldChange, openModal, formUtils, errors, fieldValidationErrors, country, }: UseUboQuestionnaireProps) => {
+    registerGuidanceQuestion: (fieldName: keyof UboQuestionnaireSchema) => {
+        name: keyof UboQuestionnaireSchema;
+        value: import("../components/Individual/forms/IndividualOnfido/GuidanceQuestion/GuidanceQuestion").GuidanceQuestionValue | null | undefined;
+        onChange: (e: any) => void;
+        onDescriptionLinkClick: (() => void) | undefined;
+        question: string;
+        descriptionLinkText: string | undefined;
+        errorMessage: string | boolean;
+    };
+};
+export {};

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

@@ -3,6 +3,16 @@ import type { GetTranslationOptions } from './utils';
 export declare class Language {
     private readonly supportedLocales;
     readonly translations: Translations;
+    /**
+     * @deprecated in favor of the `language` property returned from the
+     * i18n instance from i18next
+     *
+     * @example
+     * ```tsx
+     * const { i18n } = useTranslation('common');
+     * console.log(`${i18n.language} is the selected language code`); // ex. "en-US"
+     * ```
+     */
     readonly locale: string;
     constructor({ locale, translations, allowedLocales, }: {
         locale?: string;

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

@@ -1,14 +1,28 @@
-import type introductionKeys from '#shared/language/introduction/en-US.json';
-import type bankingKeys from '../components/BankAccount/language/en-US.json';
+import type { Namespace, SelectorOptions } from 'i18next';
+import type { i18nextResources } from './i18next';
 import type translations from './locales/en-US.json';
+/**
+ * @deprecated as an alternative, please use `NsTranslationKey`
+ */
 export type TranslationKey = keyof typeof translations;
-export type TranslationItem = string;
-export type Translations = Record<TranslationKey, TranslationItem>;
+export type Translations = Record<TranslationKey, string>;
+/**
+ * @deprecated as an alternative, please use `NsTranslationObject`
+ */
 export type TranslationObject = {
     key: TranslationKey;
     values: Record<string, string>;
 };
+/**
+ * @deprecated as an alternative, please use `NsTranslatable`
+ */
 export type Translatable = TranslationKey | TranslationObject;
-export type CommonKey = keyof typeof translations;
-export type IntroductionKey = keyof typeof introductionKeys;
-export type BankingKey = keyof typeof bankingKeys;
+export type NamespaceToKeyMap = {
+    [K in keyof i18nextResources]: keyof i18nextResources[K];
+};
+export type NsTranslationKey<NS extends Namespace> = NS extends keyof NamespaceToKeyMap ? NamespaceToKeyMap[NS] : never;
+export type NsTranslationObject<NS extends Namespace> = {
+    key: NsTranslationKey<NS>;
+    values: SelectorOptions;
+};
+export type NsTranslatable<NS extends Namespace> = NsTranslationKey<NS> | NsTranslationObject<NS>;

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

@@ -1,6 +1,6 @@
 import type { TFunction } from 'i18next';
 import type { CountryCode } from '../types/datasets/country-code';
-import type { Translatable, TranslationItem, TranslationKey, Translations } from './types';
+import type { Translatable, TranslationKey, Translations } from './types';
 /**
  * Matches a string with one of the locales
 
@@ -31,7 +31,7 @@ export interface GetTranslationOptions {
 /**
  * Returns a translation string by key
  */
-export declare const getTranslationByKey: (translations: Translations, key: TranslationKey, options?: GetTranslationOptions) => TranslationItem | null;
+export declare const getTranslationByKey: (translations: Translations, key: TranslationKey, options?: GetTranslationOptions) => string | null;
 /**
  * Returns a LanguageCode from locale
  * @param locale - The locale the user wants to use

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

@@ -1,7 +1,7 @@
 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 ACQUIRING_BUSINESS_LINE: "ACQUIRING_BUSINESS_LINE";
     readonly INTRODUCTION: "INTRODUCTION";
     readonly TASKS_OVERVIEW: "TASKS_OVERVIEW";
     readonly REVIEW: "REVIEW";

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

@@ -1,4 +1,5 @@
 import type { ExperimentName } from '../context/ExperimentContext/types';
+import type { BooleanSettingName } from '../context/SettingsContext/types';
 import type { TopLevelDataSchema } from '../context/StateContext/types';
 import type { AccountFormatRequirements } from '../datasets/generators/getAccountFormatForCountry';
 import type { Scenario } from '../core/models/api/get-scenarios';
@@ -13,6 +14,7 @@ export interface FormRulesParams<TLDS extends TopLevelDataSchema> {
     country: CountryCode;
     taskType: TaskType;
     isExperimentEnabled?: (experiment: ExperimentName) => boolean;
+    isSettingEnabled?: (setting: BooleanSettingName) => boolean;
     requiredFields?: Partial<AccountFormatRequirements>;
     rootLegalEntity?: ExistingLegalEntity;
     accountHolder?: AccountHolderOption;

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

@@ -1,8 +1,32 @@
 import type { TopLevelDataSchema } from '../context/StateContext/types';
+import type { VerificationError } from '../core/models/api/verification-error';
+import type { FormConfiguration } from '../types/form-configuration';
 import type { FormRules } from '../types/form-rules';
 import type { AnyTLDSFieldName } from './getFieldsWithExistingData';
-export declare const linkedFieldsMap: Partial<Record<AnyTLDSFieldName, AnyTLDSFieldName>>;
-export declare function calculateLinkedRequiredFields<OuterFormSchema extends TopLevelDataSchema>(field: Extract<keyof OuterFormSchema[keyof OuterFormSchema], string>, formId: Extract<keyof OuterFormSchema, string>, customRules: FormRules<string>): {
+export declare const linkedFieldsMap: Partial<Record<AnyTLDSFieldName, AnyTLDSFieldName[]>>;
+interface CalculateLinkedRequiredFieldsOptions<OuterFormSchema extends TopLevelDataSchema> {
+    field: Extract<keyof OuterFormSchema[keyof OuterFormSchema], string>;
+    formId: Extract<keyof OuterFormSchema, string>;
+    customRules: FormRules<string>;
+    scenarioConfiguration: FormConfiguration<OuterFormSchema, string>;
+    dataMissingErrors: VerificationError[];
+    formFieldsWithExistingData: string[];
+}
+/**
+ * This function is used to process fields linked to other fields that have custom rules that can return either REQUIRED or OPTIONAL
+ * depending on the value of their links. An example of this is the Vat number, this will be REQUIRED when exemption is false but OPTIONAL when exemption is true.
+ * This needs to be done due to functions like isFieldRequiredToRemediateDataMissingError, which do not take into account the custom rules and instead mark
+ * these fields as required regardless of the rule.
+ *
+ * @param field - Field being processed
+ * @param formId - Form this field is associated to
+ * @param customRules - The rules associated to the form flow
+ * @param scenarioConfiguration - The static configuration returned from the scenario, i.e. L1, L, etc
+ * @param dataMissingErrors - Missing data problems on the LE response
+ * @param formFieldsWithExistingData - The current fields that have existing data within the LE response
+ */
+export declare function calculateLinkedRequiredFields<OuterFormSchema extends TopLevelDataSchema>({ field, formId, customRules, scenarioConfiguration, dataMissingErrors, formFieldsWithExistingData, }: CalculateLinkedRequiredFieldsOptions<OuterFormSchema>): {
     isRequiredFromLinkedField: boolean;
     isOptionalFromLinkedField: boolean;
 };
+export {};

package/dist/types/utils/analytics/convertToEmbeddedEvent.d.ts

@@ -0,0 +1,9 @@
+import type { AnalyticsEventPayload, EventQueueItem, EventType, MixpanelProperty } from '../../core/user-events';
+import type { EmbeddedAnalyticsSessionRequest } from '../../hooks/useAnalytics/useAnalytics';
+type EmbeddedEventItem = {
+    eventType: EventType;
+    eventName: string;
+    eventData: AnalyticsEventPayload | Record<string, MixpanelProperty>;
+};
+export declare const convertToEmbeddedEvent: (eventQueueItem: EventQueueItem, sessionData: EmbeddedAnalyticsSessionRequest) => EmbeddedEventItem & EmbeddedAnalyticsSessionRequest;
+export {};

package/dist/types/utils/analytics/debouncedInputEvent.d.ts

@@ -0,0 +1,30 @@
+import type { UserEvents } from '../../core/user-events';
+export declare const debouncedInputEvent: (userEvents: UserEvents, properties: {
+    actionType: import("../../core/user-events").ActionType;
+    entityType?: import("../../core/models/api/legal-entity-type").LegalEntityType | undefined;
+    task?: string | undefined;
+    page?: string | undefined;
+    field?: string | undefined;
+    returnType?: "backend" | "validation" | (string & {}) | undefined;
+    returnValue?: string | string[] | undefined;
+    toPage?: string | undefined;
+    content?: string | undefined;
+    label?: string | undefined;
+    documentType?: string | undefined;
+    fileExtention?: string[] | undefined;
+    additionalData?: {
+        [key: string]: import("../../core/user-events").MixpanelProperty;
+    } | undefined;
+    'Experiment name'?: string | undefined;
+    'Variant name'?: string | undefined;
+    legalEntityName?: string | undefined;
+    companyStructure?: import("../../core/models/api/company-types-value").CompanyTypesValue | undefined;
+    usedAdditionalAddress?: boolean | undefined;
+    countryOfRegistration?: string | undefined;
+    roles?: import("../../core/models/api/decision-maker-type").DecisionMakerType[] | import("../../core/models/api/legal-entity-association").LegalEntityAssociationType[] | undefined;
+    noOfDecisionMakers?: number | undefined;
+    remainingDecisionMakers?: import("../../core/models/api/legal-entity-association").LegalEntityAssociation[] | undefined;
+    actionLevel?: ("task" | "page" | "field" | "journey") | undefined;
+} & {
+    field: string;
+}) => void;

package/dist/types/utils/analytics/getAnalyticsAssociatedEntityDetails.d.ts

@@ -0,0 +1,13 @@
+import type { LegalEntityType } from '../../core/models/api/legal-entity-type';
+import type { LegalEntity } from '../../core/models/api/legal-entity';
+import type { AccountHolderOption } from '../../types/accountHolder';
+type AssociatedEntityDetails = {
+    associatedLegalEntityId?: string;
+    associatedLegalEntityType?: LegalEntityType;
+};
+/**
+ * Gets associated legal entity type and ID for the base tracking payload
+ * Based on selected account holder type
+ */
+export declare const getAnalyticsAssociatedEntityDetails: (rootLegalEntity: LegalEntity, accountHolderType?: AccountHolderOption) => AssociatedEntityDetails | undefined;
+export {};

package/dist/types/utils/analytics/trackNavigation.d.ts

@@ -0,0 +1,10 @@
+import type { ActionType, AdditionalEventProperties, UserEvents } from '../../core/user-events';
+export interface TrackNavigationProps {
+    userEvents: UserEvents;
+    actionType: ActionType;
+    toForm?: string;
+    label: string;
+    returnValue?: 'success' | 'validation error';
+    additionalTrackingParams?: Partial<AdditionalEventProperties>;
+}
+export declare const trackNavigation: ({ userEvents, actionType, toForm, label, returnValue, additionalTrackingParams, }: TrackNavigationProps) => void;

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

@@ -21,6 +21,7 @@ export interface CreateDocumentRequestProps {
     existingDocument?: ExistingDocument;
 }
 export declare const createDocumentRequest: ({ entityId, entityType, documentType, page1, page2, description, existingDocument, }: CreateDocumentRequestProps) => Promise<Document | undefined>;
+export declare const fileToBase64: (file: File) => Promise<string>;
 export declare const getFileExtention: (fileName: string) => string | undefined;
 /**
  * Merges existing attachments from API with newly added attachments in UI