@adyen/kyc-components 2.2.3 → 2.2.5

package/dist/types/core/Services/get-fonts.d.ts

@@ -0,0 +1,16 @@
+interface AdditionalFormats {
+    eot?: string;
+    woff?: string;
+    woff2?: string;
+    ttf?: string;
+    otf?: string;
+}
+interface FontProps {
+    (fontFamily: string, fontStyle: string, fontWeight: string, fontSrc: string, additionalFormats?: AdditionalFormats): any;
+}
+/**
+ * Exposes a method intended to load fonts and icon fonts.
+ */
+export declare const loadFont: FontProps;
+export declare const loadADLIconFont: (loadingContext: string) => void;
+export {};

package/dist/types/core/Services/get-images.d.ts

@@ -0,0 +1,2 @@
+export declare const loadFlags: (loadingContext: string) => Promise<void>;
+export declare const loadDocumentGuidance: (loadingContext?: string) => Promise<void>;

package/dist/types/core/Services/http.d.ts

@@ -0,0 +1,4 @@
+import { HttpOptions } from './types';
+export declare const http: <T>(options: HttpOptions, data?: any, responseType?: XMLHttpRequestResponseType) => Promise<T>;
+export declare const httpGet: <T>(options: HttpOptions, data?: any) => Promise<T>;
+export declare const httpPost: <T>(options: HttpOptions, data?: any) => Promise<T>;

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

@@ -0,0 +1,16 @@
+import { CoreContextType } from '../Context/CoreContext';
+export type FetchErrorLevel = 'silent' | 'info' | 'warn' | 'error' | 'fatal';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'OPTIONS' | 'PATCH';
+export type RequestContext = Partial<CoreContextType> & Required<Pick<CoreContextType, 'loadingContext' | 'clientKey'>>;
+export interface HttpOptions {
+    accept?: string;
+    contentType?: string;
+    errorMessage?: string;
+    headers?: HeadersInit;
+    loadingContext?: string;
+    clientKey?: string;
+    method?: HttpMethod;
+    path: string;
+    errorLevel?: FetchErrorLevel;
+    errorHandler?: (response: any) => any;
+}

package/dist/types/core/Services/utils.d.ts

@@ -0,0 +1,5 @@
+import { FetchErrorLevel, HttpOptions } from './types';
+export declare const getRequestObject: (options: HttpOptions, data?: any) => RequestInit;
+export declare const getRequestUrl: (loadingContext: string, path: string, clientKey: string) => string;
+export declare const handleFetchError: (message: string, level: FetchErrorLevel) => void;
+export declare const handleFetchResponse: (response: Response, responseType: XMLHttpRequestResponseType) => Promise<any>;

package/dist/types/core/Services/validate-phone-number.d.ts

@@ -0,0 +1,3 @@
+import { ValidationResponse } from '../models/errors/validation-error';
+import { RequestContext } from './types';
+export declare const validatePhoneNumber: (context: RequestContext, phoneNumber: string) => Promise<ValidationResponse>;

package/dist/types/core/Services/verify-id-number.d.ts

@@ -0,0 +1,3 @@
+import { VerifyIdNumberRequest, VerifyIdNumberResponse } from '../models/api/verify-id-number';
+import { RequestContext } from './types';
+export declare const verifyIdNumber: (context: RequestContext, request: VerifyIdNumberRequest) => Promise<VerifyIdNumberResponse | undefined>;

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

@@ -0,0 +1,11 @@
+export declare const ON_CHANGE_DEBOUNCE_DURATION = 200;
+export declare const KEYBOARD_KEYS: {
+    readonly arrowDown: "ArrowDown";
+    readonly arrowUp: "ArrowUp";
+    readonly enter: "Enter";
+    readonly escape: "Escape";
+    readonly space: " ";
+    readonly tab: "Tab";
+};
+export type KeyboardKeyLabel = keyof typeof KEYBOARD_KEYS;
+export type KeyboardKey = (typeof KEYBOARD_KEYS)[KeyboardKeyLabel];

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

@@ -0,0 +1,26 @@
+import { ComponentOptions } from '../components';
+import { BaseElement } from '../components/BaseElement';
+import { UIElement } from '../components/UIElement';
+import { CoreOptions } from './types';
+export declare class Core {
+    options: CoreOptions & {
+        loadingContext: string;
+    };
+    components: UIElement[];
+    constructor(coreOptions: CoreOptions);
+    create: <Name extends "payoutAccount" | "taskList" | "pci" | "individualDropin" | "companyDropin" | "trustDropin" | "soleProprietorDropin">(componentName: Name, componentOptions: ComponentOptions<Name>) => UIElement;
+    /**
+     * Updates global configurations, resets the internal state and remounts each element.
+     * @param options - props to update
+     * @returns this - the element instance
+     */
+    update: (options: Partial<CoreOptions>) => this;
+    updateLocale: ({ locale }: Pick<CoreOptions, 'locale'>) => this;
+    /**
+     * Remove the reference of a component
+     * @param component - reference to the component to be removed
+     * @returns this - the element instance
+     */
+    remove: (component: BaseElement<object>) => this;
+    private getUpdatedOptions;
+}

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

@@ -0,0 +1,4 @@
+export declare class AdyenKycSdkError extends Error {
+    sourceError: any;
+    constructor(message: string, sourceError?: Error);
+}

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

@@ -0,0 +1,11 @@
+import type { AsyncValidatorRules, ValidatorMode } from '../../utils/validation/types';
+import { ValidationResult } from '../../utils/validation/ValidationResult';
+import type { FormState } from './useForm/types';
+export type AsyncValidationResults<FormSchema> = Partial<Record<keyof FormSchema, ValidationResult>>;
+export type TriggerAsyncValidation<FormSchema> = (field: keyof FormSchema, formState: FormState<FormSchema>, mode: ValidatorMode) => void;
+export type UseAsyncValidator<FormSchema> = {
+    asyncValidationResults: AsyncValidationResults<FormSchema>;
+    triggerAsyncValidation: TriggerAsyncValidation<FormSchema>;
+    clearAsyncValidationResults: () => void;
+};
+export declare const useAsyncValidator: <FormSchema>(asyncRules?: Partial<{ [field in keyof FormSchema]: import("../../utils/validation/types").AsyncValidatorRule<FormSchema[field], FormSchema>; }>) => UseAsyncValidator<FormSchema>;

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

@@ -0,0 +1,9 @@
+import { ComponentChildren, ComponentProps } from 'preact';
+import { MutableRef } from 'preact/hooks';
+export declare function useClickAwayListener(ref: MutableRef<HTMLElement | null>, onClickAway: () => void): void;
+interface ClickAwayWrapperProps extends ComponentProps<'div'> {
+    children: ComponentChildren;
+    onClickAway: () => void;
+}
+export declare const ClickAwayWrapper: ({ children, onClickAway, ...divProps }: ClickAwayWrapperProps) => import("preact").JSX.Element;
+export {};

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

@@ -0,0 +1,5 @@
+import { DataSet } from '../models/api/data-set';
+export declare function useDataset(datasetIdentifier: string, skip?: boolean): {
+    dataset: DataSet;
+    loaded: boolean;
+};

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

@@ -0,0 +1,3 @@
+export * from './reducer';
+export * from './types';
+export * from './useForm';

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 { TriggerAsyncValidation } from '../useAsyncValidator';
+import type { TriggerStaticValidation } from '../useStaticValidator';
+import type { FieldValue, FormState } from './types';
+export interface InitOptions<FormSchema> {
+    schema: (keyof FormSchema)[];
+    staticValidate: TriggerStaticValidation<FormSchema>;
+    asyncValidate: TriggerAsyncValidation<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, staticValidate, asyncValidate, }: 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> {
+    staticValidate: TriggerStaticValidation<FormSchema>;
+    asyncValidate: TriggerAsyncValidation<FormSchema>;
+    formatters?: FormatRules<FormSchema>;
+}
+export type GetReducerResults<FormSchema> = Reducer<FormState<FormSchema>, ReducerAction<FormSchema>>;
+export declare function reducer<FormSchema>({ staticValidate, asyncValidate, 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 type { 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/hooks/useStaticValidator/index.d.ts

@@ -0,0 +1 @@
+export * from './useStaticValidator';

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

@@ -0,0 +1,7 @@
+import type { FieldContext, FieldData, ValidatorRule, ValidatorRules } from '../../../utils/validation/types';
+import { ValidationResult } from '../../../utils/validation/ValidationResult';
+export type TriggerStaticValidation<FormSchema> = (fieldData: FieldData<FormSchema>, context?: FieldContext<FormSchema>) => ValidationResult;
+export type UseStaticValidator<FormSchema> = {
+    triggerStaticValidation: TriggerStaticValidation<FormSchema>;
+};
+export declare const useStaticValidator: <FormSchema>(rules?: Partial<{ [field in keyof FormSchema]: ValidatorRule<FormSchema[field], FormSchema> | ValidatorRule<FormSchema[field], FormSchema>[]; }>) => UseStaticValidator<FormSchema>;

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

@@ -0,0 +1,9 @@
+import type { CountryCode } from '../country-code';
+export interface Address {
+    city?: string;
+    country?: CountryCode;
+    postalCode?: string;
+    stateOrProvince?: string;
+    street?: string;
+    street2?: string;
+}

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

@@ -0,0 +1,5 @@
+export interface Attachment {
+    content: string;
+    pageType?: string;
+    pageName?: string;
+}

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

@@ -0,0 +1,30 @@
+import { Problem } from './problem';
+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;
+    problems: Problem[];
+    verificationStatus: VerificationStatus;
+}

package/dist/types/core/models/api/company-types-value.d.ts

@@ -0,0 +1,10 @@
+export declare enum CompanyTypesValue {
+    PRIVATE_COMPANY = "privateCompany",
+    PUBLIC_COMPANY = "listedPublicCompany",
+    UNLISTED_PUBLIC_COMPANY = "unlistedPublicCompany",
+    INCORPORATED_PARTNERSHIP = "partnershipIncorporated",
+    INCORPORATED_ASSOCIATION = "associationIncorporated",
+    GOVERNMENTAL_ORGANIZATION = "governmentalOrganization",
+    NON_PROFIT_OR_CHARITABLE = "nonProfit",
+    SOLE_PROPRIETORSHIP = "soleProprietorship"
+}

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

@@ -0,0 +1,57 @@
+import { BankVerificationVendor } from '../../../components/BankVerification/types';
+import { ServiceAgreementAcceptanceInfo, ServiceAgreementType } from '../../../components/Dropins/ServiceAgreementDropinComponent/types';
+export interface PciTemplateRequest {
+    language: string;
+}
+export interface PciTemplateResponse extends PciTemplateRequest {
+    pciTemplateReferences: PciTemplateReferences;
+    content: string;
+}
+export interface PciQuestionnaires {
+    data: PciQuestionnaire[];
+}
+export interface PciQuestionnaire {
+    id: string;
+    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;
+    hasDocuments?: boolean;
+}
+export interface ServiceAgreementRequest {
+    type: ServiceAgreementType;
+    language: string;
+}
+export interface ServiceAgreementResponse extends ServiceAgreementRequest {
+    id: string;
+    termsOfServiceDocumentId: string;
+    document: string | undefined;
+}
+export interface ServiceAgreementSignRequest {
+    acceptedBy: string;
+}
+export interface ServiceAgreementSignResponse extends ServiceAgreementSignRequest {
+    id: string;
+    language: string;
+    termsOfServiceDocumentId: string;
+    type: ServiceAgreementType;
+}
+export interface ServiceAgreementStatus {
+    termsOfServiceTypes: ServiceAgreementType[];
+}
+export interface ServiceAgreementAcceptanceInfos {
+    data: ServiceAgreementAcceptanceInfo[];
+}
+export type BankVerificationVendorsResponse = BankVerificationVendor[];

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

@@ -0,0 +1,5 @@
+export type DataSet = DataSetItem[];
+export interface DataSetItem {
+    id: string;
+    name: string;
+}

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

@@ -0,0 +1,6 @@
+export declare enum DecisionMakerType {
+    CONTROLLING_PERSON = "uboThroughControl",
+    OWNER = "uboThroughOwnership",
+    SIGNATORY = "signatory",
+    DIRECTOR = "director"
+}

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

@@ -0,0 +1,29 @@
+import { Attachment } from './attachment';
+export interface Document {
+    attachments?: Attachment[];
+    description: string;
+    id?: string;
+    number?: string;
+    owner: {
+        id: string;
+        type: string;
+    };
+    type: DocumentType;
+}
+export declare enum DocumentType {
+    BANK_STATEMENT = "bankStatement",
+    DRIVERS_LICENSE = "driversLicense",
+    IDENTITY_CARD = "identityCard",
+    NATIONAL_ID_NUMBER = "nationalIdNumber",
+    PASSPORT = "passport",
+    PROOF_OF_ADDRESS = "proofOfAddress",
+    PROOF_OF_NATIONAL_ID_NUMBER = "proofOfNationalIdNumber",
+    PROOF_OF_RESIDENCY = "proofOfResidency",
+    REGISTRATION_DOCUMENT = "registrationDocument",
+    VAT_DOCUMENT = "vatDocument",
+    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

@@ -0,0 +1,4 @@
+export declare enum EntityType {
+    BANK_ACCOUNT = "BankAccount",
+    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[];
+}