@adyen/kyc-components 1.6.2 → 2.1.0

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

@@ -0,0 +1,38 @@
+import { Reducer } from 'preact/hooks';
+import type { FormatRules, ValidationRuleResult, ValidatorMode } from '../../../utils/validation/types';
+import type { Validator } from '../../../utils/validation/Validator';
+import type { AsyncValidate } from '../useAsyncValidator';
+import type { FieldValue, FormState } from './types';
+export interface InitOptions<FormSchema> {
+    schema: (keyof FormSchema)[];
+    synchronusValidate: Validator<FormSchema>;
+    asynchronusValidate: AsyncValidate<FormSchema>;
+    defaultData?: FormSchema;
+    maskedFields?: (keyof FormSchema)[];
+    fieldProblems?: Record<keyof FormSchema, boolean>;
+    formatters?: FormatRules<FormSchema>;
+}
+/**
+ * Processes default data and sets initial state
+ */
+export declare function init<FormSchema>({ schema, defaultData, fieldProblems, maskedFields, formatters, synchronusValidate, asynchronusValidate, }: InitOptions<FormSchema>): FormState<FormSchema>;
+export type ReducerActionType = 'setData' | 'setValid' | 'setErrors' | 'setFieldProblems' | 'updateField' | 'mergeForm' | 'setSchema' | 'validateForm';
+export interface ReducerAction<FormSchema> {
+    type: ReducerActionType;
+    key?: keyof FormSchema;
+    mode?: ValidatorMode;
+    value?: FieldValue<FormSchema> | ValidationRuleResult | boolean;
+    schema?: (keyof FormSchema)[];
+    defaultData?: FormSchema;
+    formValue?: FormState<FormSchema>;
+    selectedSchema?: (keyof FormSchema)[];
+    maskedFields?: (keyof FormSchema)[];
+    fieldProblems?: Record<keyof FormSchema, boolean>;
+}
+export interface GetReducerOptions<FormSchema> {
+    synchronusValidate: Validator<FormSchema>;
+    asynchronusValidate: AsyncValidate<FormSchema>;
+    formatters?: FormatRules<FormSchema>;
+}
+export type GetReducerResults<FormSchema> = Reducer<FormState<FormSchema>, ReducerAction<FormSchema>>;
+export declare function reducer<FormSchema>({ synchronusValidate, asynchronusValidate, formatters, }: GetReducerOptions<FormSchema>): GetReducerResults<FormSchema>;

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

@@ -0,0 +1,87 @@
+import { StateUpdater } from 'preact/hooks';
+import { TranslationKey } from '../../../language/types';
+import type { ValidationRuleResult, ValidatorMode, ValidatorRules } from '../../../utils/validation/types';
+import { CountryCode } from '../../models/country-code';
+import type { EntityProblems } from '../../models/errors/entity-problems';
+import { FormVerificationErrors } from '../../models/errors/form-verification-errors';
+import { FormModel } from '../../models/form';
+export type FieldValue<FormSchema> = FormSchema[keyof FormSchema] | null;
+export interface FormState<FormSchema> {
+    schema: Array<keyof FormSchema>;
+    data: FormSchema;
+    errors: Record<keyof FormSchema, ValidationRuleResult | null>;
+    valid: Record<keyof FormSchema, boolean>;
+    fieldProblems: Record<keyof FormSchema, boolean>;
+    maskedFields?: Array<keyof FormSchema>;
+    isValid?: boolean;
+    dataStoreId?: string;
+    local?: FormState<FormSchema> | Partial<FormState<FormSchema>>;
+}
+export interface Form<FormSchema> extends FormState<FormSchema> {
+    setData: (key: keyof FormSchema, value: FieldValue<FormSchema>) => void;
+    setValid: (key: keyof FormSchema, value: boolean) => void;
+    setErrors: (key: keyof FormSchema, value: ValidationRuleResult | null) => void;
+    setFieldProblems: (fieldProblems: Record<keyof FormSchema, boolean>) => void;
+    handleChangeFor: (key: keyof FormSchema, mode?: ValidatorMode) => (e: any) => void;
+    triggerValidation: (schema?: Array<keyof FormSchema>) => void;
+    mergeForm: (formValue: FormState<FormSchema>) => void;
+}
+export interface BaseFormProps<FormSchema> {
+    placeholders?: {
+        [Field in keyof FormSchema]: TranslationKey;
+    };
+    labels?: {
+        [Field in keyof FormSchema]: TranslationKey;
+    };
+    data?: FormSchema;
+    validators?: ValidatorRules<FormSchema>;
+    ref?: any;
+    heading?: string;
+    name?: string;
+    description?: string;
+    readOnly?: boolean;
+    shouldValidate?: boolean;
+    onChange?(state: FormState<FormSchema>): void;
+}
+export interface BaseOuterFormProps<FormSchema> extends BaseFormProps<FormSchema> {
+    problems?: EntityProblems;
+    capabilities?: string[];
+    country?: CountryCode;
+    activeForm?: FormModel;
+    requiredFields?: {
+        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+    };
+    optionalFields?: {
+        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+    };
+    verifyFields?: {
+        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+    };
+    readOnlyFields?: {
+        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+    };
+    maskedFields?: {
+        [InnerFormName in keyof FormSchema]: Array<keyof FormSchema[InnerFormName]>;
+    };
+    evaluateConfiguration?: (data: FormSchema) => void;
+    setCustomFormNavigationHandlers?(formId: string, onNext: () => void, onBack: () => void): void;
+    setHideDropinLayout?: StateUpdater<boolean>;
+    setHideNavigation?: StateUpdater<boolean>;
+    setHideFooter?: StateUpdater<boolean>;
+    setHideOnHomeButton?: StateUpdater<boolean>;
+    setHideBackButton?: StateUpdater<boolean>;
+    setSubmitButtonLabel?: StateUpdater<string>;
+    setSkipSubmitAndGoTaskList?: StateUpdater<boolean>;
+}
+export interface BaseInnerFormProps<FormSchema> extends BaseFormProps<FormSchema> {
+    formVerificationErrors?: FormVerificationErrors;
+    fieldValidationErrors?: Record<keyof FormSchema, boolean>;
+    requiredFields?: Array<keyof FormSchema>;
+    maskedFields?: Array<keyof FormSchema>;
+    optionalFields?: Array<keyof FormSchema>;
+    verifyFields?: Array<keyof FormSchema>;
+    readOnlyFields?: Array<keyof FormSchema>;
+    id?: string;
+    dataStoreId?: string;
+    capabilities?: string[];
+}

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

@@ -0,0 +1,13 @@
+import type { AsyncValidatorRules, FormatRules, ValidatorRules } from '../../../utils/validation/types';
+import { Form } from './types';
+export interface UseFormOptions<FormSchema> {
+    schema: (keyof FormSchema)[] | ((data: Partial<FormSchema>) => (keyof FormSchema)[]);
+    defaultData?: FormSchema;
+    rules?: ValidatorRules<FormSchema>;
+    asyncRules?: AsyncValidatorRules<FormSchema>;
+    formatters?: FormatRules<FormSchema>;
+    shouldValidate?: boolean;
+    fieldProblems?: Record<keyof FormSchema, boolean>;
+    maskedFields?: (keyof FormSchema)[];
+}
+export declare function useForm<FormSchema>({ schema, defaultData, rules, asyncRules, fieldProblems, maskedFields, formatters, shouldValidate, }: UseFormOptions<FormSchema>): Form<FormSchema>;

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

@@ -0,0 +1,2 @@
+export declare const omitKeys: (obj: any, omit: any) => {};
+export declare const addKeys: (obj: any, add: any, initialValue: any, defaultData: any, pendingData: any) => any;

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

@@ -0,0 +1,22 @@
+import { StateUpdater } from 'preact/hooks';
+import { TranslationKey } from '../../language/types';
+import { EntityProblems } from '../models/errors/entity-problems';
+import { FormModelWithValidity } from '../models/form';
+import { BaseTrackingPayload } from '../utils';
+export interface FormComposer {
+    handleNextClick(): void;
+    handleBackClick(): void;
+    nextButtonLabel: string;
+    gotoFormByFormIndex(index: number): void;
+    activeForm: FormModelWithValidity;
+    shouldValidate: boolean;
+    setShouldValidate: StateUpdater<boolean>;
+}
+export declare const useFormComposer: ({ problems, baseTrackingPayload, forms, formRef, submitButtonLabel, onSubmit, }: {
+    problems: EntityProblems;
+    baseTrackingPayload: BaseTrackingPayload;
+    forms: FormModelWithValidity[];
+    formRef: any;
+    submitButtonLabel?: TranslationKey;
+    onSubmit(): void;
+}) => FormComposer;

package/dist/types/core/hooks/useIdVerificationToken.d.ts

@@ -0,0 +1,11 @@
+import { DropinAPIHandlers } from '../../components/Dropins/types';
+import { UserDetails } from '../../components/IdVerification/types';
+import { LoadingStatus } from '../../components/internal/LoaderWrapper/constants';
+export declare const useIdVerificationToken: ({ userDetails, handleGetIdVerificationToken, onIdVerificationError, }: {
+    userDetails: UserDetails;
+    handleGetIdVerificationToken: Required<DropinAPIHandlers>['handleGetIdVerificationToken'];
+    onIdVerificationError: (error: any) => void;
+}) => {
+    sdkToken: string;
+    loadingStatus: LoadingStatus;
+};

package/dist/types/core/hooks/useKycExternalApi.d.ts

@@ -0,0 +1,23 @@
+import { DataSet } from '../models/api/data-set';
+import { GetPayoutAccountFormatResponse } from '../models/api/get-account-format';
+import { GetAllowedCountriesResponse } from '../models/api/get-allowed-countries';
+import { GetAllowedLocalesResponse } from '../models/api/get-allowed-locales';
+import { GetConfigurationRequest, GetConfigurationResponse } from '../models/api/get-configuration';
+import { VerifyIdNumberRequest, VerifyIdNumberResponse } from '../models/api/verify-id-number';
+import { CountryCode } from '../models/country-code';
+import { ValidationResponse } from '../models/errors/validation-error';
+export type KycExternalApi = {
+    getConfiguration: (request: GetConfigurationRequest) => Promise<GetConfigurationResponse>;
+    getPayoutAccountFormat: (country: CountryCode) => Promise<GetPayoutAccountFormatResponse>;
+    getAllowedCountries: () => Promise<GetAllowedCountriesResponse>;
+    getAllowedLocales: () => Promise<GetAllowedLocalesResponse>;
+    getDataset: (name: string, locale: string) => Promise<DataSet>;
+    loadFlags: () => Promise<void>;
+    loadDocumentGuidance: () => Promise<void>;
+    verifyIdNumber: (request: VerifyIdNumberRequest) => Promise<VerifyIdNumberResponse | undefined>;
+    validatePhoneNumber: (phoneNumber: string) => Promise<ValidationResponse>;
+};
+/**
+ * @description Hook that allows use of current KycExternalApi requests without needing to pass in context.
+ */
+export declare const useKycExternalApi: () => KycExternalApi;

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

@@ -0,0 +1,25 @@
+import { CountryBankVerificationVendors } from '../../components/BankVerification/types';
+import { LoadingStatus } from '../../components/internal/LoaderWrapper/constants';
+import { GetPayoutAccountFormatResponse } from '../models/api/get-account-format';
+import { GetConfigurationResponse, PayoutRequiredFields } from '../models/api/get-configuration';
+import { CountryCode } from '../models/country-code';
+import { FieldConfigurations } from '../models/field-configurations';
+export type ParseConfiguration = (configuration: GetConfigurationResponse & {
+    requiredFields: PayoutRequiredFields | undefined;
+    bankVerificationAvailable?: boolean;
+    country: CountryCode;
+}) => FieldConfigurations<any>;
+export interface UseScenarioConfigurationOptions {
+    getConfigurationData: () => Promise<GetConfigurationResponse>;
+    parseConfiguration: ParseConfiguration;
+    country: CountryCode;
+    setLoadingStatus: (loadingStatus: LoadingStatus) => void;
+    getPayoutAccountFormatData?: () => Promise<GetPayoutAccountFormatResponse>;
+    instantVerificationEnabled?: boolean;
+}
+export interface ScenarioConfiguration {
+    fieldConfigurations: FieldConfigurations<any> | undefined;
+    requiredFields: PayoutRequiredFields | undefined;
+    bankVerificationVendors: CountryBankVerificationVendors | undefined;
+}
+export declare const useScenarioConfiguration: ({ getConfigurationData, getPayoutAccountFormatData, parseConfiguration, country, instantVerificationEnabled, setLoadingStatus, }: UseScenarioConfigurationOptions) => ScenarioConfiguration;

package/dist/types/core/models/api/address-search.d.ts

@@ -0,0 +1,28 @@
+import { CountryCode } from '../country-code';
+/**
+ * Contains the address types used by the search address api.
+ */
+export interface AddressSearchRequest {
+    country: CountryCode;
+    text: string;
+    container?: string;
+}
+export interface Address {
+    city?: string;
+    country?: CountryCode;
+    postalCode?: string;
+    stateOrProvince?: string;
+    street?: string;
+    houseNumberOrName?: string;
+}
+export interface AddressSearchItem {
+    description: string;
+    highlight: string;
+    id: string;
+    text: string;
+    type: string;
+    addressAmount?: string;
+}
+export interface AddressSearchResponse {
+    results?: AddressSearchItem[];
+}

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

@@ -1,18 +1,9 @@
-export default interface Address {
+import type { CountryCode } from '../country-code';
+export interface Address {
     city?: string;
-    country?: string;
+    country?: CountryCode;
     postalCode?: string;
     stateOrProvince?: string;
     street?: string;
     street2?: string;
 }
-export interface AddressLoqate {
-    description: string;
-    highlight: string;
-    id: string;
-    text: string;
-    type: string;
-}
-export interface AddressResponse {
-    results?: AddressLoqate[];
-}

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

@@ -1,4 +1,4 @@
-export default interface Attachment {
+export interface Attachment {
     content: string;
     pageType?: string;
     pageName?: string;

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

@@ -1,6 +1,27 @@
-import { VerificationStatus } from './verification-status';
 import { Problem } from './problem';
-export default interface Capability {
+import { VerificationStatus } from './verification-status';
+export declare enum Capabilities {
+    AUTHORISED_PAYMENT_INSTRUMENT_USER = "authorisedPaymentInstrumentUser",
+    GET_GRANT_OFFERS = "getGrantOffers",
+    ISSUE_BANK_ACCOUNT = "issueBankAccount",
+    ISSUE_CARD = "issueCard",
+    RECEIVE_FROM_TRANSFER_INSTRUMENT = "receiveFromTransferInstrument",
+    RECEIVE_FROM_BALANCE_ACCOUNT = "receiveFromBalanceAccount",
+    RECEIVE_FROM_PLATFORM_PAYMENTS = "receiveFromPlatformPayments",
+    RECEIVE_FROM_THIRD_PARTY = "receiveFromThirdParty",
+    RECEIVE_PAYMENTS = "receivePayments",
+    RECEIVE_GRANTS = "receiveGrants",
+    SEND_TO_BALANCE_ACCOUNT = "sendToBalanceAccount",
+    SEND_TO_TRANSFER_INSTRUMENT = "sendToTransferInstrument",
+    SEND_TO_THIRD_PARTY = "sendToThirdParty",
+    USE_CARD = "useCard",
+    USE_CARD_IN_RESTRICTED_COUNTRIES = "useCardInRestrictedCountries",
+    USE_CARD_IN_RESTRICTED_INDUSTRIES = "useCardInRestrictedIndustries",
+    WITHDRAW_FROM_ATM = "withdrawFromAtm",
+    WITHDRAW_FROM_ATM_IN_RESTRICTED_COUNTRIES = "withdrawFromAtmInRestrictedCountries"
+}
+export type CapabilityType = `${Capabilities}`;
+export interface Capability {
     enabled: string;
     requested: string;
     allowed: string;

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

@@ -1,4 +1,5 @@
 import { BankVerificationVendor } from '../../../components/BankVerification/types';
+import { ServiceAgreementAcceptanceInfo, ServiceAgreementType } from '../../../components/Dropins/ServiceAgreementDropinComponent/types';
 export interface PciTemplateRequest {
     language: string;
 }
@@ -7,7 +8,7 @@ export interface PciTemplateResponse extends PciTemplateRequest {
     content: string;
 }
 export interface PciQuestionnaires {
-    data: Array<PciQuestionnaire>;
+    data: PciQuestionnaire[];
 }
 export interface PciQuestionnaire {
     id: string;
@@ -21,24 +22,22 @@ export interface SignedBy {
     signedBy: string;
     pciTemplateReferences: PciTemplateReferences;
 }
-export interface PciTemplateReferences {
-    pciTemplateReferences: Array<string>;
-}
+export type PciTemplateReferences = string[];
 export interface PciQuestionnaireIds {
-    ids: Array<string>;
+    ids: string[];
 }
 export interface PciStatus {
     signingRequired: string | boolean;
     hasDocuments?: boolean;
 }
 export interface ServiceAgreementRequest {
-    type: string;
+    type: ServiceAgreementType;
     language: string;
 }
 export interface ServiceAgreementResponse extends ServiceAgreementRequest {
     id: string;
     termsOfServiceDocumentId: string;
-    document: string;
+    document: string | undefined;
 }
 export interface ServiceAgreementSignRequest {
     acceptedBy: string;
@@ -47,32 +46,12 @@ export interface ServiceAgreementSignResponse extends ServiceAgreementSignReques
     id: string;
     language: string;
     termsOfServiceDocumentId: string;
-    type: string;
+    type: ServiceAgreementType;
 }
 export interface ServiceAgreementStatus {
-    termsOfServiceTypes: Array<string>;
-}
-export interface AddressRequest {
-    country: string;
-    text: string;
-    container?: string;
-}
-export interface Address {
-    city?: string;
-    country?: string;
-    postalCode?: string;
-    stateOrProvince?: string;
-    street?: string;
-    houseNumberOrName?: string;
-}
-export interface AddressItem {
-    description: string;
-    highlight: string;
-    id: string;
-    text: string;
-    type: string;
+    termsOfServiceTypes: ServiceAgreementType[];
 }
-export interface AddressResponse {
-    results: Array<AddressItem>;
+export interface ServiceAgreementAcceptanceInfos {
+    data: ServiceAgreementAcceptanceInfo[];
 }
-export declare type BankVerificationVendorsResponse = BankVerificationVendor[];
+export type BankVerificationVendorsResponse = BankVerificationVendor[];

package/dist/types/core/models/api/data-set.d.ts

@@ -1,4 +1,4 @@
-export declare type DataSet = DataSetItem[];
+export type DataSet = DataSetItem[];
 export interface DataSetItem {
     id: string;
     name: string;

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

@@ -1,6 +1,6 @@
-import Attachment from './attachment';
-export default interface Document {
-    attachments: Attachment[];
+import { Attachment } from './attachment';
+export interface Document {
+    attachments?: Attachment[];
     description: string;
     id?: string;
     number?: string;
@@ -21,5 +21,9 @@ export declare enum DocumentType {
     PROOF_OF_RESIDENCY = "proofOfResidency",
     REGISTRATION_DOCUMENT = "registrationDocument",
     VAT_DOCUMENT = "vatDocument",
-    CONSTITUTIONAL_DOCUMENT = "constitutionalDocument"
+    CONSTITUTIONAL_DOCUMENT = "constitutionalDocument",
+    DRIVING_LICENCE = "driving_licence",
+    NATIONAL_IDENTITY_CARD = "national_identity_card",
+    RESIDENCE_PERMIT = "residence_permit",
+    PROOF_OF_ORGANIZATION_TAX_INFO = "proofOfOrganizationTaxInfo"
 }

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

@@ -0,0 +1,9 @@
+import { DocumentType } from './document';
+export interface DocumentDetail {
+    id: string;
+    active: boolean;
+    description: string;
+    fileName: string;
+    modificationDate: string;
+    type: DocumentType;
+}

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

@@ -1,5 +1,4 @@
 export declare enum EntityType {
     BANK_ACCOUNT = "BankAccount",
-    LEGAL_ENTITY = "LegalEntity",
-    DOCUMENTS = "Documents"
+    LEGAL_ENTITY = "LegalEntity"
 }

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

@@ -0,0 +1,5 @@
+import { PayoutRequiredFields } from './get-configuration';
+export interface GetPayoutAccountFormatResponse {
+    iban?: PayoutRequiredFields;
+    local?: PayoutRequiredFields;
+}

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

@@ -0,0 +1,4 @@
+import { CountryCode } from '../country-code';
+export interface GetAllowedCountriesResponse {
+    countries: CountryCode[];
+}

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

@@ -0,0 +1,3 @@
+export interface GetAllowedLocalesResponse {
+    locales: string[];
+}

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

@@ -0,0 +1,62 @@
+import type { CountryBankVerificationVendors } from '../../../components/BankVerification/types';
+import type { TaskTypes } from '../../../components/TaskList/types';
+import type { CountryCode } from '../country-code';
+import type { LegalEntityType } from './legal-entity-type';
+type LengthSpecifier = `:${number}`;
+type Optional<T extends string> = T | '';
+type IbanRule = `iban${LengthSpecifier}${Optional<LengthSpecifier>}`;
+type DigitsRule = `digits${LengthSpecifier}${Optional<LengthSpecifier>}`;
+type BicRule = 'bic_either8or11';
+type NotImplementedRule = `${string} not implemented`;
+export type ValidationName = 'iban' | 'digits' | 'bic_either8or11';
+export type ValidationRule = IbanRule | DigitsRule | BicRule | NotImplementedRule;
+interface RequiredField {
+    Field: {
+        fieldName: string;
+        validationRule?: ValidationRule;
+    };
+}
+export interface PayoutRequiredFields {
+    currency?: string;
+    bankStatementRequirement: 'OPTIONAL' | 'REQUIRED';
+    fields: RequiredField[];
+}
+export interface PayoutFormatOptions {
+    iban?: PayoutRequiredFields;
+    local?: PayoutRequiredFields;
+}
+/**
+ * @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",
+    L_REGDOC = "L_REGDOC",
+    L_TAXDOC = "L_TAXDOC",
+    L_PROOFOFADDRESS = "L_PROOFOFADDRESS"
+}
+export type Scenario = `${Scenarios}`;
+export type IndividualScenario = `${Scenarios.L0}` | `${Scenarios.L1}` | `${Scenarios.L1_ID}` | `${Scenarios.L1_IDO}` | `${Scenarios.L1_NAT}` | `${Scenarios.L1_IDDOC}`;
+export type OrganizationScenario = `${Scenarios.L0}` | `${Scenarios.L1}` | `${Scenarios.L}` | `${Scenarios.L_REGDOC}` | `${Scenarios.L_TAXDOC}` | `${Scenarios.L_PROOFOFADDRESS}`;
+export interface GetConfigurationRequest {
+    country: CountryCode;
+    capabilities: string[];
+    legalEntityType: LegalEntityType;
+}
+export interface GetConfigurationResponse {
+    matchingScenario?: {
+        individual?: IndividualScenario[];
+        organization?: OrganizationScenario[];
+        trust?: Scenario[];
+        soleProprietorship?: Scenario[];
+    };
+    taskList?: TaskTypes[];
+    bankVerificationProviders?: CountryBankVerificationVendors;
+}
+export {};

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

@@ -1,6 +1,6 @@
-import Phone from './phone';
-import Address from './address';
-export default interface Individual {
+import { Address } from './address';
+import { Phone } from './phone';
+export interface Individual {
     birthData?: {
         dateOfBirth: string;
     };

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

@@ -1,4 +1,9 @@
 import { OnfidoCaptureSchema } from '../../../components/IdDocumentUpload/types';
+type OnfidoConsentType = 'privacy_notices_read';
+interface OnfidoConsent {
+    name: OnfidoConsentType;
+    granted: boolean;
+}
 export interface InstantIdVerificationTokenRequest {
     name: {
         firstName: string;
@@ -6,6 +11,7 @@ export interface InstantIdVerificationTokenRequest {
     };
     country: string;
     origin: string;
+    consents: OnfidoConsent[];
 }
 export interface InstantIdVerificationTokenResponse {
     id: string;
@@ -25,3 +31,4 @@ export interface InstantIdVerificationStartCheckResponse {
     };
     reference: string;
 }
+export {};

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

@@ -1,10 +1,10 @@
 import { DecisionMakerType } from './decision-maker-type';
 import { LegalEntityType } from './legal-entity-type';
 import { TrustMemberType } from './trust-member-type';
-export declare type LegalEntityAssociationType = DecisionMakerType | TrustMemberType | LegalEntityType.TRUST | LegalEntityType.SOLE_PROPRIETORSHIP;
-export default interface LegalEntityAssociation {
+export type LegalEntityAssociationType = DecisionMakerType | TrustMemberType | LegalEntityType.TRUST | LegalEntityType.SOLE_PROPRIETORSHIP;
+export interface LegalEntityAssociation {
     jobTitle?: string;
-    legalEntityId: string;
+    legalEntityId?: string;
     type: LegalEntityAssociationType;
     name?: string;
     entityType?: LegalEntityType;

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

@@ -1,15 +1,16 @@
-import LegalEntityAssociation from './legal-entity-association';
-import Individual from './individual';
-import Organization from './organization';
-import Capability from './capability';
-import Trust from './trust';
+import type { PartialDeep } from 'type-fest';
+import { Capability, CapabilityType } from './capability';
+import { DocumentDetail } from './documentDetail';
+import { Individual } from './individual';
+import { LegalEntityAssociation } from './legal-entity-association';
 import { LegalEntityType } from './legal-entity-type';
-import SoleProprietor from './soleProprietor';
-export default interface LegalEntity {
+import { Organization } from './organization';
+import { SoleProprietor } from './soleProprietor';
+import { TransferInstrumentOverview } from './transfer-instrument';
+import { Trust } from './trust';
+export interface LegalEntity {
     id?: string;
-    documentDetails?: {
-        id: string;
-    }[];
+    documentDetails?: DocumentDetail[];
     entityAssociations?: LegalEntityAssociation[];
     individual?: Individual;
     organization?: Organization;
@@ -17,9 +18,13 @@ export default interface LegalEntity {
     trust?: Trust;
     type?: LegalEntityType;
     capabilities?: {
-        [key: string]: Capability;
+        [key in CapabilityType]?: Capability;
     };
-    transferInstruments?: {
-        id: string;
-    }[];
+    transferInstruments?: TransferInstrumentOverview[];
+}
+export type PatchLegalEntity = Omit<PartialDeep<LegalEntity, {
+    recurseIntoArrays: true;
+}>, 'id'>;
+export interface ExistingLegalEntity extends LegalEntity {
+    id: string;
 }

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

@@ -1,7 +1,7 @@
-import Phone from './phone';
-import Address from './address';
+import { Address } from './address';
 import { CompanyTypesValue } from './company-types-value';
-export default interface Organization {
+import { Phone } from './phone';
+export interface Organization {
     description?: string;
     doingBusinessAs?: string;
     email?: string;
@@ -21,10 +21,10 @@ export default interface Organization {
     type?: CompanyTypesValue;
 }
 export declare const vatAbsenceReasons: readonly ["industryExemption", "belowTaxThreshold"];
-export declare type VatAbsenceReason = typeof vatAbsenceReasons[number];
-export declare type TaxInformation = {
+export type VatAbsenceReason = (typeof vatAbsenceReasons)[number];
+export type TaxInformation = {
     country: string;
     number: string;
     type: TaxInformationType;
 };
-export declare type TaxInformationType = 'SSN' | 'EIN' | 'ITIN' | 'ABN';
+export type TaxInformationType = 'SSN' | 'EIN' | 'ITIN' | 'ABN';