@adyen/kyc-components 3.66.4 → 3.67.0

package/dist/types/components/UnincorporatedPartnership/hooks/useUnincorporatedPartnershipNavigation.d.ts

@@ -1,4 +1,4 @@
-import type { ExistingLegalEntity, PatchLegalEntity } from '../../../core/models/api/legal-entity';
+import type { ExistingLegalEntity } from '../../../core/models/api/legal-entity';
 import { LegalEntityType } from '../../../core/models/api/legal-entity-type';
 import { UnincorporatedPartnershipMemberTypes } from '../../../core/models/api/unincorporated-partnership';
 import { TaskTypes } from '../../Shared/tasks/TaskList/types';
@@ -11,14 +11,27 @@ export interface NavigateToMemberProps {
     roleAndType?: boolean;
 }
 export interface NavigationProps {
-    setAssociatedLegalEntity: (legalEntity?: ExistingLegalEntity) => void;
     navigateTo: (taskType: TaskTypes) => void;
-    handleGetLegalEntity: (legalEntityId: string) => Promise<ExistingLegalEntity>;
-    handleUpdateLegalEntity: (data: PatchLegalEntity, legalEntityId: string) => Promise<ExistingLegalEntity>;
 }
-export declare const useUnincorporatedPartnershipNavigation: ({ setAssociatedLegalEntity, navigateTo, handleGetLegalEntity, handleUpdateLegalEntity, }: NavigationProps) => {
+export declare const useUnincorporatedPartnershipNavigation: ({ navigateTo }: NavigationProps) => {
     onNavigateToMember: ({ selectedMember, selectedRoles, selectedEntityType, roleAndType, }: NavigateToMemberProps) => Promise<void>;
     onDeleteMember: (member: UnincorporatedPartnershipMember, associatedLegalArrangement?: ExistingLegalEntity) => Promise<void>;
     activeMember: UnincorporatedPartnershipMember;
+    currentUnincorporatedPartnershipMember: {
+        documentDetails?: import("../../../core/models/api/documentDetail").DocumentDetail[];
+        entityAssociations?: import("../../../core/models/api/legal-entity-association").LegalEntityAssociation[];
+        individual?: import("../../../core/models/api/individual").Individual;
+        organization?: import("../../../core/models/api/organization").Organization;
+        soleProprietorship?: import("../../../core/models/api/sole-proprietor").SoleProprietor;
+        trust?: import("../../../core/models/api/trust").Trust;
+        unincorporatedPartnership?: import("../../../core/models/api/unincorporated-partnership").UnincorporatedPartnership;
+        capabilities?: Partial<Record<import("../../../core/models/api/capability").CapabilityName, import("../../../core/models/api/capability").Capability>>;
+        problems?: import("../../../core/models/api/problem").Problem[];
+        transferInstruments?: import("../../../core/models/api/transfer-instrument").TransferInstrumentOverview[];
+        trustedFields?: import("../../../core/models/api/legal-entity").LegalEntityTrustedFields[];
+        id: string;
+        type: LegalEntityType;
+    };
+    setActiveMember: import("preact/hooks").Dispatch<import("preact/hooks").StateUpdater<UnincorporatedPartnershipMember>>;
 };
 export {};

package/dist/types/components/UnincorporatedPartnership/mapping/unincorporatedPartnershipKeyMappings.d.ts

@@ -1,6 +1,5 @@
 import type { LegalEntity } from '../../../core/models/api/legal-entity';
-import type { DocumentMappingRecord, MappingRecord } from '../../../utils/mapping/mappingRecord';
+import type { MappingRecord } from '../../../utils/mapping/mappingRecord';
 import type { TrustSchema } from '../../Trust/forms/Trust/types';
 export declare const unincorporatedPartnershipComponentsKeyMapping: MappingRecord<TrustSchema, Pick<LegalEntity, 'unincorporatedPartnership'>>;
 export declare const unincorporatedPartnershipApiKeyMapping: MappingRecord<Pick<LegalEntity, 'unincorporatedPartnership'>, TrustSchema>;
-export declare const unincorporatedPartnershipDocumentMapping: DocumentMappingRecord<TrustSchema>;

package/dist/types/components/UnincorporatedPartnership/tasks/UnincorporatedPartnershipRoleAndType/UnincorporatedPartnershipRadioGroup.d.ts

@@ -1,8 +1,12 @@
 import { UnincorporatedPartnershipMemberTypes } from '../../../../core/models/api/unincorporated-partnership';
+import type { Translatable } from '../../../../../types';
+import type { ValidatorMode } from '../../../../utils/validation/types';
+import type { UnincorporatedPartnershipRoleAndEntityTypeSchema } from './types';
 interface UnincorporatedPartnershipRadioGroup {
-    selectedRoles: UnincorporatedPartnershipMemberTypes[];
-    setSelectedRoles: (roles: UnincorporatedPartnershipMemberTypes[]) => void;
     memberType: UnincorporatedPartnershipMemberTypes;
+    handleChangeFor: (key: keyof UnincorporatedPartnershipRoleAndEntityTypeSchema, mode?: ValidatorMode) => (value: string) => void;
+    errorMessage: boolean | Translatable;
+    value: string | undefined;
 }
-export declare const UnincorporatedPartnershipRadioGroup: ({ selectedRoles, setSelectedRoles, memberType, }: UnincorporatedPartnershipRadioGroup) => import("preact/jsx-runtime").JSX.Element;
+export declare const UnincorporatedPartnershipRadioGroup: ({ memberType, errorMessage, handleChangeFor, value, }: UnincorporatedPartnershipRadioGroup) => import("preact/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/UnincorporatedPartnership/tasks/UnincorporatedPartnershipRoleAndType/types.d.ts

@@ -0,0 +1,6 @@
+import type { LegalEntityType } from '../../../../core/models/api/legal-entity-type';
+export interface UnincorporatedPartnershipRoleAndEntityTypeSchema {
+    entityType: LegalEntityType.INDIVIDUAL | LegalEntityType.ORGANIZATION | undefined;
+    uboThroughControl?: string;
+    uboThroughOwnership?: string;
+}

package/dist/types/components/UnincorporatedPartnership/tasks/UnincorporatedPartnershipRoleAndType/validate.d.ts

@@ -0,0 +1,3 @@
+import type { ValidatorRules } from '../../../../utils/validation/types';
+import type { UnincorporatedPartnershipRoleAndEntityTypeSchema } from './types';
+export declare const unincorporatedPartnershipRoleAndTypeValidationRules: ValidatorRules<UnincorporatedPartnershipRoleAndEntityTypeSchema>;

package/dist/types/components/UnincorporatedPartnership/utils/unincorporatedPartnershipMembers.d.ts

@@ -1,6 +1,6 @@
+import type { UpdateLegalEntity } from '../../../api/legalEntity/useUpdateLegalEntity';
 import type { ExistingLegalEntity } from '../../../core/models/api/legal-entity';
 import type { LegalEntityAssociation } from '../../../core/models/api/legal-entity-association';
-import type { DropinAPIHandlers } from '../../EmbeddedDropins/OnboardingDropinComponent/DropinComposer/types';
 import type { UnincorporatedPartnershipMember } from '../tasks/UnincorporatedPartnershipMembers/types';
 /**
  * In the API response, there are multiple {@link LegalEntityAssociation}s for the same associated entity;
@@ -12,5 +12,5 @@ export declare const mapEntityAssociationsToUnincorporatedPartnershipMembers: (e
 export declare const deleteUnincorporatedPartnershipMember: ({ associatedMember, unincorporatedPartnership, handleUpdateLegalEntity, }: {
     associatedMember: UnincorporatedPartnershipMember;
     unincorporatedPartnership: ExistingLegalEntity;
-    handleUpdateLegalEntity: NonNullable<DropinAPIHandlers["handleUpdateLegalEntity"]>;
+    handleUpdateLegalEntity: UpdateLegalEntity;
 }) => Promise<void>;

package/dist/types/components/ui/atoms/Select/Select.d.ts

@@ -2,4 +2,4 @@ import './Select.scss';
 import './SelectGeneric.scss';
 import type { JSX } from 'preact';
 import type { SelectProps } from './Select.types.ts';
-export declare const Select: ({ items, filterable, readonly, onChange, selected, name, isInvalid, isValid, placeholder, isMulti, uniqueId, showSelectedItemsAsTags, isSearch, onSearch, resetSearch, loading, getSearchItem, searchText, onSearchTextChange, showSearchList, enableTracking, onBlur, maxVisibleItems, }: SelectProps) => JSX.Element;
+export declare const Select: ({ items, filterable, readonly, onChange, onSelect, selected, name, isInvalid, placeholder, label, isMulti, uniqueId, enableTracking, maxVisibleItems, getSearchItem, onBlur, text: filterTextProp, setText: setFilterTextProp, showList: showListProp, setShowList: setShowListProp, behaviour, loading, minimal, }: SelectProps) => JSX.Element;

package/dist/types/components/ui/atoms/Select/Select.types.d.ts

@@ -15,26 +15,29 @@ export interface AddressSpecificSelectItem extends SelectItem {
     highlight?: string;
 }
 interface BaseSelectProps {
-    filterable?: boolean;
+    filterable?: boolean | 'prefiltered';
     isInvalid?: boolean;
     items: ReadonlyArray<SelectItem>;
     name: string;
+    label?: string;
     placeholder?: string;
     readonly?: boolean;
-    selected: string | string[] | undefined;
-    isValid?: boolean;
     uniqueId?: string;
-    showSelectedItemsAsTags?: boolean;
-    isSearch?: boolean;
-    onSearch?: (text: string) => void;
-    resetSearch?: boolean;
-    loading?: boolean;
-    getSearchItem?: (item: SelectItem) => ComponentChild;
-    searchText?: string;
-    onSearchTextChange?: (text: string) => void;
-    showSearchList?: boolean;
     enableTracking?: boolean;
     maxVisibleItems?: number;
+    getSearchItem?: (item: SelectItem) => ComponentChild;
+    onBlur?: (e: FocusEvent) => void;
+    /** toggles minimal styling, useful for when embedded in an {@link InputGroup} */
+    minimal?: boolean;
+    /**
+     * The props below are pertinent mainly to {@link SearchAddress}
+     */
+    text?: string;
+    setText?: (text: string) => void;
+    behaviour?: 'textIsData' | 'textIsFilter';
+    showList?: boolean;
+    setShowList?: (showList: boolean) => void;
+    loading?: boolean;
 }
 interface SingleSelectOnChangeTarget {
     value: string;
@@ -52,13 +55,25 @@ export interface MultiSelectOnChangeProps {
 }
 interface SingleSelectProps extends BaseSelectProps {
     isMulti?: false;
-    onChange: (e: SingleSelectOnChangeProps) => void;
-    onBlur?: (e: FocusEvent) => void;
+    /**
+     * can either define a selected {@link SelectItem}
+     * or a `string` id, in which case we will fish through `items` to find the item with the matching id
+     */
+    selected: SelectItem | string | undefined;
+    /** @deprecated use {@link SingleSelectProps.onSelect} instead */
+    onChange?: (e: SingleSelectOnChangeProps) => void;
+    onSelect?: (selected: SelectItem) => void;
 }
 interface MultiSelectProps extends BaseSelectProps {
     isMulti: true;
-    onChange: (e: MultiSelectOnChangeProps) => void;
-    onBlur?: (e: FocusEvent) => void;
+    /**
+     * can either define selected {@link SelectItem}s
+     * or `string` ids, in which case we will fish through `items` to find items with the matching ids
+     */
+    selected: SelectItem[] | string[] | undefined;
+    /** @deprecated use {@link MultiSelectProps.onSelect} instead */
+    onChange?: (e: MultiSelectOnChangeProps) => void;
+    onSelect?: (selected: SelectItem[]) => void;
 }
 export type SelectProps = SingleSelectProps | MultiSelectProps;
 export {};

package/dist/types/components/ui/atoms/Select/useSelectFocus.d.ts

@@ -5,17 +5,16 @@ interface UseSelectFocusOptions {
     filteredItems: ReadonlySignal<SelectItem[]>;
 }
 export interface SelectFocus {
-    focused: ReadonlySignal<SelectItem | 'input' | 'button' | undefined>;
+    focused: ReadonlySignal<SelectItem | 'input' | undefined>;
     moveFocusToFirstItem(): void;
     moveFocusToLastItem(): void;
     moveFocusToNextItem(): void;
     moveFocusToPreviousItem(): void;
     focusInput(): void;
-    focusButton(): void;
     focusItem(item: SelectItem): void;
     focusDefaultItem(): void;
     focusNothing(): void;
 }
-export declare const useSelectFocus: ({ activeItems, filteredItems: items, }: UseSelectFocusOptions) => SelectFocus;
+export declare const useSelectFocus: (options: UseSelectFocusOptions) => SelectFocus;
 export declare const focusedIsItem: (focused: SelectFocus["focused"]["value"]) => focused is SelectItem;
 export {};

package/dist/types/components/ui/atoms/SelectButton/SelectButton.d.ts

@@ -1,4 +1,4 @@
 import '../Select/SelectGeneric.scss';
 import type { JSX } from 'preact';
 import type { SelectButtonProps } from './SelectButton.types';
-export declare function SelectButton({ name, active, readonly, showList, isInvalid, isValid, onClick, onButtonKeyDown, filterable, placeholder, focusProps: { focused }, ariaDescribedBy, selectListId, onInput, id, isSearch, loading, hideSearchIcon, textFilter, enableTracking, onBlur, toggleButtonRef, }: SelectButtonProps): JSX.Element;
+export declare function SelectButton({ name, active, readonly, showList, isInvalid, onClick, onButtonKeyDown, filterable, isFiltering, placeholder, label, focusProps: { focused }, ariaDescribedBy, selectListId, onInput, id, behaviour, loading, text, enableTracking, onBlur, onFocus, inputRef, minimal, }: SelectButtonProps): JSX.Element;

package/dist/types/components/ui/atoms/SelectButton/SelectButton.types.d.ts

@@ -1,47 +1,30 @@
 import type { JSX, RefObject } from 'preact';
 import type { SelectFocus } from '../Select/useSelectFocus';
-import type { SelectItem } from '../Select/Select.types';
+import type { SelectItem, SelectProps } from '../Select/Select.types';
 export interface SelectButtonProps {
     name: string;
     active: SelectItem[];
     focusProps: SelectFocus;
-    filterable: boolean;
+    filterable: boolean | 'prefiltered';
+    isFiltering: boolean;
     isInvalid: boolean;
     onButtonKeyDown: (e: JSX.TargetedKeyboardEvent<HTMLElement>) => void;
     onInput: (val: string) => void;
     placeholder: string;
+    label?: string;
     readonly: boolean;
     selectListId: string;
     showList: boolean;
-    onClick?: () => void;
-    toggleButtonRef: RefObject<HTMLButtonElement>;
-    isValid?: boolean;
+    inputRef: RefObject<HTMLInputElement>;
     ariaDescribedBy: string;
     isMulti: boolean;
     id?: string;
-    showSelectedItemsAsTags?: boolean;
-    isSearch?: boolean;
-    hideSearchIcon?: boolean;
     loading?: boolean;
-    textFilter?: string;
+    text?: string;
+    behaviour: SelectProps['behaviour'];
     enableTracking?: boolean;
-    onBlur?: (e: FocusEvent) => void;
-}
-export interface SelectButtonContentSingleProps {
-    active: SelectItem[];
-    filterInputRef: RefObject<HTMLInputElement>;
-    filterable: boolean;
-    onInput: (val: string) => void;
-    placeholder: string;
-    selectListId: string;
-    showList: boolean;
-    showSelectedItemsAsTags?: boolean;
-    isSearch?: boolean;
-    hideSearchIcon?: boolean;
-    loading?: boolean;
-    textFilter?: string;
-}
-export interface SelectedItemsAsTagsProps {
-    active: SelectItem[];
-    isMulti?: boolean;
+    onClick: () => void;
+    onBlur: (e: FocusEvent) => void;
+    onFocus: (e: JSX.TargetedFocusEvent<HTMLInputElement>) => void;
+    minimal?: boolean;
 }

package/dist/types/components/ui/atoms/SelectList/SelectList.d.ts

@@ -1,4 +1,4 @@
 import '../Select/SelectGeneric.scss';
 import type { JSX } from 'preact';
 import type { SelectListProps } from './SelectList.types';
-export declare function SelectList({ selectListId, active, filteredItems, showList, isMulti, showAbove, isSearch, loading, getSearchItem, onKeyDown, onSelect, maxVisibleItems, focusProps: { focused, focusItem, focusDefaultItem, moveFocusToNextItem, moveFocusToPreviousItem, moveFocusToFirstItem, moveFocusToLastItem, }, }: SelectListProps): JSX.Element;
+export declare function SelectList({ selectListId, active, filteredItems, showList, isMulti, inputRef, isSearch, loading, getSearchItem, onKeyDown, onSelect, minimal, maxVisibleItems, focusProps: { focused, focusItem, focusDefaultItem, moveFocusToNextItem, moveFocusToPreviousItem, moveFocusToFirstItem, moveFocusToLastItem, }, }: SelectListProps): JSX.Element;

package/dist/types/components/ui/atoms/SelectList/SelectList.types.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentChild, JSX } from 'preact';
+import type { ComponentChild, JSX, RefObject } from 'preact';
 import type { SelectFocus } from '../Select/useSelectFocus';
 import type { AddressSpecificSelectItem, SelectItem } from '../Select/Select.types';
 export interface SelectListProps {
@@ -10,10 +10,11 @@ export interface SelectListProps {
     showList: boolean;
     textFilter: string;
     isMulti: boolean;
-    showAbove?: boolean;
     isSearch?: boolean;
     loading?: boolean;
     getSearchItem?: (item: AddressSpecificSelectItem) => ComponentChild;
     maxVisibleItems?: number;
     focusProps: SelectFocus;
+    inputRef: RefObject<HTMLInputElement>;
+    minimal?: boolean;
 }

package/dist/types/components/ui/atoms/TaskStatusIndicator/TaskStatusIndicator.d.ts

@@ -1,11 +1,11 @@
 import type { TranslationKey } from '../../../../../types';
+import { TaskStatus } from '../../../../stores/globalStore/taskStatus';
 export interface StatusIndicatorProps {
-    variant: 'success' | 'inProgress' | 'error';
-    label?: string;
+    taskStatus?: TaskStatus;
 }
 export interface IndicatorLabelAndClassname {
     indicatorLabel: TranslationKey;
     indicatorClassname: string;
 }
-export declare const getIndicatorLabelAndClassnames: ({ variant, }: StatusIndicatorProps) => IndicatorLabelAndClassname;
-export declare const TaskStatusIndicator: ({ variant, label }: StatusIndicatorProps) => import("preact/jsx-runtime").JSX.Element;
+export declare const getIndicatorLabelAndClassnames: ({ taskStatus, }: StatusIndicatorProps) => IndicatorLabelAndClassname | undefined;
+export declare const TaskStatusIndicator: ({ taskStatus }: StatusIndicatorProps) => import("preact/jsx-runtime").JSX.Element;

package/dist/types/components/ui/molecules/Dropzone/FilePicker.d.ts

@@ -3,7 +3,7 @@ import type { JSX } from 'preact';
 import type { FileSchema } from '../../../../core/models/file';
 import type { TranslationKey } from '../../../../../types';
 import type { FileValidationOptions } from './validate';
-export interface FilePickerProps extends FileValidationOptions {
+interface FilePickerProps extends FileValidationOptions {
     files: FileSchema[];
     setFiles: (files: FileSchema[]) => void;
     isValid: boolean;
@@ -15,3 +15,4 @@ export interface FilePickerProps extends FileValidationOptions {
     enableTracking?: boolean;
 }
 export declare function FilePicker({ files, setFiles, isValid, errorMessage, multiple, label, name, iconPrefix, enableTracking, allowedFileTypes, maxSize, isOptional, maxNumberOfFiles, }: FilePickerProps): JSX.Element;
+export {};

package/dist/types/components/ui/molecules/InputText/InputText.d.ts

@@ -1,7 +1,8 @@
 import type { InputBaseProps } from '../../atoms/InputBase/InputBase';
-export interface InputTextProps extends InputBaseProps {
+interface InputTextProps extends InputBaseProps {
     transformInput?: (input: string) => string;
 }
 export declare const InputText: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<InputTextProps> & {
     ref?: import("preact").Ref<HTMLInputElement>;
 }>;
+export {};

package/dist/types/context/ConfigurationApiContext/ConfigurationApiContext.d.ts

@@ -1,10 +1,7 @@
-import type { DataSet } from '../../core/models/api/data-set';
 import type { GetConfigurationRequest, GetConfigurationResponse } from '../../core/models/api/get-configuration';
 import type { ValidationResponse } from '../../core/models/errors/validation-error';
-import type { DatasetIdentifier } from '../../utils/datasetUtil';
 export type ConfigurationApi = {
     getConfiguration: (request: GetConfigurationRequest) => Promise<GetConfigurationResponse>;
-    getDataset: (identifier: DatasetIdentifier, locale: string) => Promise<DataSet>;
     validatePhoneNumber: (phoneNumber: string) => Promise<ValidationResponse>;
 };
 export declare const ConfigurationApiContext: import("preact").Context<ConfigurationApi>;

package/dist/types/context/ExperimentContext/types.d.ts

@@ -112,6 +112,10 @@ export declare enum ExperimentNames {
      * SOE-5342: Make TaxID mandatory when onboarding companies for business accounts
      */
     EnableTaxIdRequiredForBusinessAccountsScenarios = "EnableTaxIdRequiredForBusinessAccountsScenarios",
+    /**
+     * Enables ja-JP locale for HO
+     */
+    EnableJaJPLocale = "EnableJaJPLocale",
     /**
      *
      */

package/dist/types/context/FormRouterContext/types.d.ts

@@ -1,9 +1,9 @@
 import type { ComponentChildren } from 'preact';
+import type { GetIdVerificationToken } from '../../api/idVerificationProviders/useIdVerificationToken';
 import type { FormModel } from '../../core/models/form';
-import type { DropinAPIHandlers } from '../../components/EmbeddedDropins/OnboardingDropinComponent/DropinComposer/types';
 export interface FormRouterProps {
     children?: ComponentChildren;
     setFormIndex: (formIndex: number) => void;
     forms: FormModel[];
-    handleGetIdVerificationToken?: DropinAPIHandlers['handleGetIdVerificationToken'];
+    handleGetIdVerificationToken?: GetIdVerificationToken;
 }

package/dist/types/context/SettingsContext/types.d.ts

@@ -23,6 +23,7 @@ export declare enum SettingNames {
     ViewOnboardingGuidance = "viewOnboardingGuidance",
     InstantBankVerification = "instantBankVerification",
     ShowServiceAgreementsFirst = "showServiceAgreementsFirst",
+    ShowBusinessFinancingFirst = "showBusinessFinancingFirst",
     EnforceLegalAge = "enforceLegalAge"
 }
 export type SettingName = `${SettingNames}`;
@@ -45,6 +46,7 @@ export interface Settings {
     transferInstrumentLimit: number;
     instantBankVerification: boolean;
     showServiceAgreementsFirst: boolean;
+    showBusinessFinancingFirst: boolean;
     enforceLegalAge: boolean;
 }
 export type ProvidedSettings = Partial<Settings>;

package/dist/types/core/analytics.d.ts

@@ -10,5 +10,20 @@ type AssociatedLeAnalyticsParams = {
     associatedLegalEntityOrgType?: string;
 };
 export declare const getAssociatedLeAnalyticsPayload: ({ associatedLegalEntity, associatedLegalEntityOrg, }: GetAssociatedLeAnalyticsParams) => AssociatedLeAnalyticsParams;
-export declare const debouncedInputEvent: (...args: any[]) => void;
+export declare const debouncedInputEvent: (properties: {
+    [x: string]: import("./user-events").MixpanelProperty;
+    actionType: import("./user-events").ActionType;
+    entityType?: import("./models/api/legal-entity-type").LegalEntityType;
+    page?: string;
+    field?: string;
+    returnType?: "backend" | "validation" | (string & {});
+    returnValue?: string | string[];
+    additionalData?: string | string[];
+    label?: string;
+    'Experiment name'?: string;
+    'Variant name'?: string;
+    actionLevel?: "task" | "field" | "journey" | "page";
+} & {
+    field: string;
+}) => void;
 export {};

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

@@ -18,17 +18,11 @@ interface PciQuestionnaire {
     createdAt: string;
     validUntil: string;
 }
-export interface DownloadPci extends PciQuestionnaire {
-    content: string;
-}
 export interface SignedBy {
     signedBy: string;
     pciTemplateReferences: PciTemplateReferences;
 }
 export type PciTemplateReferences = string[];
-export interface PciQuestionnaireIds {
-    ids: string[];
-}
 export interface PciStatus {
     signingRequired: string | boolean;
 }
@@ -42,9 +36,6 @@ export interface ServiceAgreementResponse extends ServiceAgreementRequest {
     termsOfServiceDocumentId: string;
     document: string | undefined;
 }
-export interface ServiceAgreementUnacceptedDocumentRequest extends ServiceAgreementRequest {
-    termsOfServiceDocumentFormat?: TermsOfServiceDocumentFormat;
-}
 export interface ServiceAgreementSignRequest {
     acceptedBy: string;
 }
@@ -54,16 +45,6 @@ export interface ServiceAgreementSignResponse extends ServiceAgreementSignReques
     termsOfServiceDocumentId: string;
     type: ServiceAgreementType;
 }
-export interface ServiceAgreementStatus {
-    termsOfServiceTypes: ServiceAgreementType[];
-}
-export interface ServiceAgreementAcceptedDocumentResponse {
-    id: string;
-    document: string;
-    termsOfServiceAcceptanceReference: string;
-    termsOfServiceDocumentFormat: string;
-}
-export type ServiceAgreementUnacceptedDocumentResponse = ServiceAgreementResponse;
 export interface ServiceAgreementAcceptanceInfos {
     data: ServiceAgreementAcceptanceInfo[];
 }

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

@@ -44,8 +44,7 @@ export interface Organization {
     support?: CustomerSupport;
     taxReportingClassification?: TaxReportingClassification;
 }
-export declare const vatAbsenceReasons: readonly ["industryExemption", "belowTaxThreshold", "countryWithoutVatOrGstSystem"];
-export type VatAbsenceReason = (typeof vatAbsenceReasons)[number];
+export type VatAbsenceReason = 'industryExemption' | 'belowTaxThreshold' | 'countryWithoutVatOrGstSystem';
 export type TaxInformation = {
     country: CountryCode;
     number?: string;

package/dist/types/core/models/state-code.d.ts

@@ -1,6 +1,6 @@
 export type StateCode = StateCodeUS | StateCodeBR;
 export type StateCodeBR = `${StateCodesBR}`;
-export declare const enum StateCodesBR {
+declare const enum StateCodesBR {
     Acre = "AC",
     Alagoas = "AL",
     Amazonas = "AM",
@@ -83,3 +83,4 @@ export declare const enum StateCodesUS {
     Wisconsin = "WI",
     Wyoming = "WY"
 }
+export {};

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

@@ -1,5 +1,6 @@
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
-export interface UseCanSeeIntroductionProps {
+interface UseCanSeeIntroductionProps {
     legalEntity: ExistingLegalEntity;
 }
 export declare const useCanSeeIntroduction: ({ legalEntity }: UseCanSeeIntroductionProps) => boolean;
+export {};

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

@@ -2,14 +2,13 @@ import type { AccountHolderOption } from '../../core/types/AccountHolder.types';
 import type { Translatable } from '../../../types';
 import type { ExistingLegalEntity } from '../../core/models/api/legal-entity';
 import type { UniqueEntityAssociation } from '../../components/Shared/EntityAssociation/types';
-import type { SingpassLinkResponse } from '../../components/EmbeddedDropins/OnboardingDropinComponent/DropinComposer/types';
-export declare enum SingpassMyInfoLoginActionType {
+declare enum SingpassMyInfoLoginActionType {
     LOADING = "LOADING",
     SUCCESS = "SUCCESS",
     FAILURE = "FAILURE",
     RESET = "RESET"
 }
-export interface SingpassMyInfoLoginAction {
+interface SingpassMyInfoLoginAction {
     type: SingpassMyInfoLoginActionType;
     isLoading: boolean;
     isSuccess: boolean;
@@ -19,10 +18,9 @@ export type SingpassMyInfoLoginState = Omit<SingpassMyInfoLoginAction, 'type'>;
 interface UseSingpassMyInfoLoginProps {
     legalEntity?: ExistingLegalEntity;
     accountHolder: AccountHolderOption | undefined;
-    handleOpenSingpassAuthorizationLink: (() => Promise<SingpassLinkResponse>) | undefined;
 }
 export declare const getTrustedEntityAssociations: (legalEntityTrustedFields: string[]) => Partial<UniqueEntityAssociation>[];
-export declare const useSingpassMyInfoLogin: ({ legalEntity, accountHolder, handleOpenSingpassAuthorizationLink, }: UseSingpassMyInfoLoginProps) => {
+export declare const useSingpassMyInfoLogin: ({ legalEntity, accountHolder, }: UseSingpassMyInfoLoginProps) => {
     isEligibleForSingpass: boolean;
     state: SingpassMyInfoLoginState;
     handleInitiateSingpassMyInfoLogin: () => Promise<string>;

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

@@ -1,6 +1,6 @@
 import type { AnalyticsEventPayload, EventQueueItem, EventType, MixpanelProperty, UserEvents } from '../core/user-events';
 import type { EmbeddedAnalyticsSessionRequest } from '../core/models/api/analytics';
-export type UseAnalyticsProps = {
+type UseAnalyticsProps = {
     userEvents: UserEvents;
     sessionId: string | undefined;
     sessionData: EmbeddedAnalyticsSessionRequest;

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

@@ -0,0 +1,14 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
+import type { LegalEntityAssociationType } from '../core/models/api/legal-entity-association';
+type UseAssociatedLegalEntity = Pick<UseQueryResult<ExistingLegalEntity>, 'data' | 'refetch' | 'isLoading'>;
+/**
+ * Fetches and returns an entity of the given type which is associated to the given root legal entity.
+ * Also returns a callback that can be used to refetch the associated entity.
+ *
+ * @param parentLegalEntity the parent legal entity to find an associated entity for
+ * @param associationType the type of associated entity to fetch.
+ * If multiple types are provided, the first matching association is used.
+ */
+export declare function useAssociatedLegalEntity(parentLegalEntity: ExistingLegalEntity | undefined, associationType: LegalEntityAssociationType | LegalEntityAssociationType[]): UseAssociatedLegalEntity;
+export {};

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

@@ -1,6 +1,2 @@
 import type { ExistingLegalEntity } from '../core/models/api/legal-entity';
-import type { DropinAPIHandlers } from '../components/EmbeddedDropins/OnboardingDropinComponent/DropinComposer/types';
-export declare const useAssociatedLegalRepresentative: ({ legalEntity, handleGetLegalEntity, }: {
-    legalEntity: ExistingLegalEntity;
-    handleGetLegalEntity?: DropinAPIHandlers["handleGetLegalEntity"];
-}) => ExistingLegalEntity | undefined;
+export declare const useAssociatedLegalRepresentative: (legalEntity: ExistingLegalEntity) => ExistingLegalEntity | undefined;

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

@@ -6,6 +6,6 @@ export type TriggerAsyncValidation<FormSchema> = (field: keyof FormSchema, formS
 export type UseAsyncValidator<FormSchema> = {
     asyncValidationResults: AsyncValidationResults<FormSchema>;
     triggerAsyncValidation: TriggerAsyncValidation<FormSchema>;
-    clearAsyncValidationResults: () => void;
+    clearAsyncValidationResults: (field: keyof FormSchema) => void;
 };
 export declare const useAsyncValidator: <FormSchema>(asyncRules?: AsyncValidatorRules<FormSchema>) => UseAsyncValidator<FormSchema>;

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

@@ -1,15 +1,7 @@
 import type { DropinAPIHandlers } from '../components/EmbeddedDropins/OnboardingDropinComponent/DropinComposer/types';
 export type ComponentApi = {
-    getLegalEntity: Required<DropinAPIHandlers>['handleGetLegalEntity'];
     updateLegalEntity: Required<DropinAPIHandlers>['handleUpdateLegalEntity'];
-    createLegalEntity: Required<DropinAPIHandlers>['handleCreateLegalEntity'];
-    getIdVerificationToken: Required<DropinAPIHandlers>['handleGetIdVerificationToken'];
-    idVerificationStartCheck: Required<DropinAPIHandlers>['handleGetIdVerificationStartCheck'];
-    getAddress: Required<DropinAPIHandlers>['handleFindAddress'];
-    searchAddress: Required<DropinAPIHandlers>['handleAddressSearch'];
-    openSingpassAuthorizationLink: Required<DropinAPIHandlers>['handleOpenSingpassAuthorizationLink'];
 };
-export declare const COMPONENTS_API_VERSION = "v1";
 export declare const makeComponentApi: (rootLegalEntityId: string, base: string) => ComponentApi;
 /**
  * @description Hook that allows use of current componentApi requests without needing to pass in context.

package/dist/types/hooks/useForm/reducer.d.ts

@@ -30,7 +30,7 @@ export interface ReducerAction<FormSchema> {
     selectedSchema?: (keyof FormSchema)[];
     fieldProblems?: Partial<Record<keyof FormSchema, boolean>>;
 }
-export interface GetReducerOptions<FormSchema> {
+interface GetReducerOptions<FormSchema> {
     staticValidate: TriggerStaticValidation<FormSchema>;
     asyncValidate: TriggerAsyncValidation<FormSchema>;
     obscuredFields?: (keyof FormSchema)[];
@@ -40,3 +40,4 @@ export interface GetReducerOptions<FormSchema> {
 }
 export type GetReducerResults<FormSchema> = Reducer<FormState<FormSchema>, ReducerAction<FormSchema>>;
 export declare function reducer<FormSchema>({ staticValidate, asyncValidate, obscuredFields, optionalFields, trustedFields, formatters, }: GetReducerOptions<FormSchema>): GetReducerResults<FormSchema>;
+export {};

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

@@ -64,7 +64,7 @@ export interface FormState<FormSchema> {
     dataStoreId?: string;
     local?: FormState<FormSchema> | Partial<FormState<FormSchema>>;
 }
-export type InnerFormLabels<InnerFormSchema> = {
+type InnerFormLabels<InnerFormSchema> = {
     [Field in keyof InnerFormSchema]: TranslationKey;
 };
 export type OuterFormLabels<OuterFormSchema> = {
@@ -157,3 +157,4 @@ export interface BaseInnerFormProps<FormSchema> extends BaseFormProps<FormSchema
     capabilities?: CapabilityName[];
     isTopLevelEntity?: boolean;
 }
+export {};