@adyen/kyc-components 4.0.0-beta.0 → 4.0.0-beta.3

package/dist/types/api/legalEntity/useUpdateLegalEntity.d.ts

@@ -1,19 +1,19 @@
 import { type MutationOptions } from '@tanstack/react-query';
 import type { ExistingLegalEntity, NewPatchLegalEntity } from '../../core/models/api/legal-entity';
-type SuccessResponse = ExistingLegalEntity;
-export type UpdateLegalEntity = (data: NewPatchLegalEntity) => Promise<SuccessResponse>;
-export declare const useUpdateLegalEntity: (options?: Omit<MutationOptions<SuccessResponse, Error, NewPatchLegalEntity>, "mutationFn" | "onSuccess">) => import("@tanstack/react-query").UseMutationResult<{
-    documentDetails?: import("../../core/models/api/document").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[];
+type LegalEntityResponse = ExistingLegalEntity;
+export type UpdateLegalEntity = (data: NewPatchLegalEntity) => Promise<LegalEntityResponse>;
+export declare const useUpdateLegalEntity: (options?: Omit<MutationOptions<LegalEntityResponse, Error, NewPatchLegalEntity>, "mutationFn" | "onSuccess">) => import("@tanstack/react-query").UseMutationResult<{
+    documentDetails?: import("../../core/models/api/document").DocumentDetail[] | undefined;
+    entityAssociations?: import("../../core/models/api/legal-entity-association").LegalEntityAssociation[] | undefined;
+    individual?: import("../../core/models/api/individual").Individual | undefined;
+    organization?: import("../../core/models/api/organization").Organization | undefined;
+    soleProprietorship?: import("../../core/models/api/sole-proprietor").SoleProprietor | undefined;
+    trust?: import("../../core/models/api/trust").Trust | undefined;
+    unincorporatedPartnership?: import("../../core/models/api/unincorporated-partnership").UnincorporatedPartnership | undefined;
+    capabilities?: Partial<Record<import("../../core/models/api/capability").CapabilityName, import("../../core/models/api/capability").Capability>> | undefined;
+    problems?: import("../../core/models/api/problem").Problem[] | undefined;
+    transferInstruments?: import("../../core/models/api/transfer-instrument").TransferInstrumentOverview[] | undefined;
+    trustedFields?: import("../../core/models/api/legal-entity").LegalEntityTrustedFields[] | undefined;
     id: string;
     type: import("../../core/models/api/legal-entity-type").LegalEntityType;
 }, Error, NewPatchLegalEntity, unknown>;

package/dist/types/api/onboardingStatus/onboardingStatus.types.d.ts

@@ -0,0 +1,7 @@
+import type { OnboardingStatus } from '../../core/models/api/view-verification-status';
+import type { components } from './onboardingStatus.contract';
+export type GenerateOnboardingLinkResponse = components['schemas']['OnboardingStatusUrlResponse'];
+export type GenerateOnboardingLinkRequest = components['schemas']['OnboardingStatusUrlRequest'];
+export type OnboardingStatusResponse = {
+    status: OnboardingStatus;
+};

package/dist/types/api/onboardingStatus/useGenerateOnboardingLink.d.ts

@@ -1,12 +1,9 @@
 import { type MutationOptions } from '@tanstack/react-query';
-import type { components } from './onboardingStatus.contract';
-type SuccessResponse = components['schemas']['OnboardingStatusUrlResponse'];
-type Request = components['schemas']['OnboardingStatusUrlRequest'];
-export declare const useGenerateOnboardingLink: (options?: Omit<MutationOptions<SuccessResponse, unknown, Request>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<{
+import type { GenerateOnboardingLinkRequest, GenerateOnboardingLinkResponse } from './onboardingStatus.types';
+export declare const useGenerateOnboardingLink: (options?: Omit<MutationOptions<GenerateOnboardingLinkResponse, unknown, GenerateOnboardingLinkRequest>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<{
     redirectUrl?: string;
 }, unknown, {
     locale?: string;
     returnUrl?: string;
     themeId?: string;
 }, unknown>;
-export {};

package/dist/types/api/onboardingStatus/useOnboardingStatus.d.ts

@@ -1,4 +1,4 @@
-import type { OnboardingStatusResponse } from '../../core/models/api/view-verification-status';
 import type { QueryOptions } from '../types';
+import type { OnboardingStatusResponse } from './onboardingStatus.types';
 export type QueryKeyOnboardingStatus = ['onboardingStatus'];
 export declare const useOnboardingStatus: (options?: QueryOptions<OnboardingStatusResponse>) => import("@tanstack/react-query").UseQueryResult<OnboardingStatusResponse, Error>;

package/dist/types/api/pciTemplate/pciTemplate.types.d.ts

@@ -0,0 +1,9 @@
+import type { EndpointFromPaths } from '../types';
+import type { components, paths } from './pci.contract';
+export type PciEndpoint = EndpointFromPaths<keyof paths>;
+export type PciQuestionnaireResponse = components['schemas']['PciQuestionnaireResponse'];
+export type PciQuestionnaireListEndpoint = Extract<PciEndpoint, `legalEntities/${string}/pci/questionnaires`>;
+export type PciQuestionnaireListResponse = components['schemas']['PciQuestionnairesResponse'];
+export type PciStatusEndpoint = Extract<PciEndpoint, `legalEntities/${string}/pci/signingRequired`>;
+export type PciStatusResponse = components['schemas']['PciSigningStatusResponse'];
+export type PciStatusRequest = components['schemas']['PciSigningStatusRequest'];

package/dist/types/api/pciTemplate/usePciQuestionnaire.d.ts

@@ -1,8 +1,6 @@
-import type { components } from './pci.contract';
-type SuccessResponse = components['schemas']['PciQuestionnaireResponse'];
+import type { PciQuestionnaireResponse } from './pciTemplate.types';
 /**
  * Returns the details of a questionnaire, notably the content that
  * is used to generate the pdf in the frontend (to base64 blob, appending .pdf)
  */
-export declare const getPciQuestionnaire: (legalEntityId: string, baseUrl: string, documentId: string) => Promise<SuccessResponse>;
-export {};
+export declare const getPciQuestionnaire: (legalEntityId: string, baseUrl: string, documentId: string) => Promise<PciQuestionnaireResponse>;

package/dist/types/api/pciTemplate/usePciQuestionnaireList.d.ts

@@ -1,14 +1,12 @@
-import type { EndpointFromPaths, QueryOptions } from '../types';
-import type { components, paths } from './pci.contract';
-type PciEndpoint = EndpointFromPaths<keyof paths>;
-export type PciQuestionnaireListEndpoint = Extract<PciEndpoint, `legalEntities/${string}/pci/questionnaires`>;
-export type SuccessResponse = components['schemas']['PciQuestionnairesResponse'];
+import type { QueryOptions } from '../types';
+import type { PciQuestionnaireListResponse } from './pciTemplate.types';
 export type QueryKeyPciQuestionnaireList = ['pciQuestionnaireList'];
 /**
  * Returns a list of questionnaires for the legalEntity
  */
-export declare const getPciQuestionnaireList: (legalEntityId: string, baseUrl: string) => Promise<SuccessResponse>;
-export declare const usePciQuestionnaireList: (options?: QueryOptions<SuccessResponse>) => import("@tanstack/react-query").UseQueryResult<{
-    data?: components["schemas"]["PciDocumentInfo"][];
+export declare const getPciQuestionnaireList: (legalEntityId: string, baseUrl: string) => Promise<{
+    data?: import("./pci.contract").components["schemas"]["PciDocumentInfo"][];
+}>;
+export declare const usePciQuestionnaireList: (options?: QueryOptions<PciQuestionnaireListResponse>) => import("@tanstack/react-query").UseQueryResult<{
+    data?: import("./pci.contract").components["schemas"]["PciDocumentInfo"][];
 }, Error>;
-export {};

package/dist/types/api/pciTemplate/usePciStatus.d.ts

@@ -1,11 +1,6 @@
-import type { EndpointFromPaths, QueryOptions } from '../types';
-import type { components, paths } from './pci.contract';
-type PciEndpoint = EndpointFromPaths<keyof paths>;
-export type PciStatusEndpoint = Extract<PciEndpoint, `legalEntities/${string}/pci/signingRequired`>;
-export type SuccessResponse = components['schemas']['PciSigningStatusResponse'];
-type Request = components['schemas']['PciSigningStatusRequest'];
-export type QueryKeyPciStatus = ['pciStatus', Request];
-export declare const usePciStatus: (data: Request, options?: QueryOptions<SuccessResponse>) => import("@tanstack/react-query").UseQueryResult<{
+import type { QueryOptions } from '../types';
+import type { PciStatusRequest, PciStatusResponse } from './pciTemplate.types';
+export type QueryKeyPciStatus = ['pciStatus', PciStatusRequest];
+export declare const usePciStatus: (data: PciStatusRequest, options?: QueryOptions<PciStatusResponse>) => import("@tanstack/react-query").UseQueryResult<{
     signingRequired?: boolean;
 }, Error>;
-export {};

package/dist/types/api/pciTemplate/usePciTemplate.d.ts

@@ -2,9 +2,9 @@ import type { EndpointFromPaths, QueryOptions } from '../types';
 import type { components, paths } from './pci.contract';
 type PciEndpoint = EndpointFromPaths<keyof paths>;
 export type PciTemplateEndpoint = Extract<PciEndpoint, `legalEntities/${string}/pci/generatePciTemplates`>;
-type SuccessResponse = components['schemas']['GeneratePciDescriptionResponse'];
+type PciTemplateResponse = components['schemas']['GeneratePciDescriptionResponse'];
 type Request = components['schemas']['GeneratePciDescriptionRequest'];
-type ModifiedSuccessResponse = Required<SuccessResponse>;
+type ModifiedSuccessResponse = Required<PciTemplateResponse>;
 export type QueryKeyPciTemplate = ['pciTemplate', Request];
 export declare const usePciTemplate: (data: Request, options?: QueryOptions<ModifiedSuccessResponse>) => import("@tanstack/react-query").UseQueryResult<Required<{
     content?: string;

package/dist/types/api/pciTemplate/useSignPci.d.ts

@@ -3,9 +3,9 @@ import type { EndpointFromPaths } from '../types';
 import type { components, paths } from './pci.contract';
 type PciEndpoint = EndpointFromPaths<keyof paths>;
 export type PciSignEndpoint = Extract<PciEndpoint, `legalEntities/${string}/pci/signPciTemplates`>;
-type SuccessResponse = components['schemas']['PciSigningResponse'];
+type SignPciResponse = components['schemas']['PciSigningResponse'];
 type Request = components['schemas']['PciSigningRequest'];
-export declare const useSignPci: (options?: Omit<MutationOptions<SuccessResponse, unknown, Request>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<{
+export declare const useSignPci: (options?: Omit<MutationOptions<SignPciResponse, unknown, Request>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<{
     pciQuestionnaireIds?: string[];
     signedBy?: string;
 }, unknown, {

package/dist/types/api/providersConfiguration/providersConfiguration.types.d.ts

@@ -0,0 +1,9 @@
+import type { components } from './providersConfiguration.contract';
+type Provider = 'address' | 'idNumber' | 'idDocument';
+export type ProvidersConfigurationResponse = Omit<components['schemas']['ProvidersStatusesResponse'], 'statuses'> & {
+    statuses: Record<Provider, components['schemas']['ProviderStatusResponse']>;
+};
+export type ProvidersConfigurationRequest = components['schemas']['ProvidersStatusesRequest'] & {
+    providers: Provider[];
+};
+export {};

package/dist/types/api/providersConfiguration/useProviderStatus.d.ts

@@ -1,19 +1,9 @@
 import type { QueryOptions } from '../types';
-import type { components } from './providersConfiguration.contract';
-type Provider = 'address' | 'idNumber' | 'idDocument';
-type Response = components['schemas']['ProvidersStatusesResponse'];
-export type CorrectedResponse = Omit<Response, 'statuses'> & {
-    statuses: Record<Provider, components['schemas']['ProviderStatusResponse']>;
-};
-type Request = components['schemas']['ProvidersStatusesRequest'];
-type CorrectedRequest = Request & {
-    providers: Provider[];
-};
-export type QueryKeyProvidersStatus = ['providersStatus', CorrectedRequest];
+import type { ProvidersConfigurationRequest, ProvidersConfigurationResponse } from './providersConfiguration.types';
+export type QueryKeyProvidersStatus = ['providersStatus', ProvidersConfigurationRequest];
 /**
  * Asks the backend if 3rd party providers like Loqate and Onfido are available.
  *
  * Bank verification providers are not included, as these are handled by Open Banking.
  */
-export declare const useProviderStatus: (data: CorrectedRequest, options?: QueryOptions<CorrectedResponse>) => import("@tanstack/react-query").UseQueryResult<CorrectedResponse, Error>;
-export {};
+export declare const useProviderStatus: (data: ProvidersConfigurationRequest, options?: QueryOptions<ProvidersConfigurationResponse>) => import("@tanstack/react-query").UseQueryResult<ProvidersConfigurationResponse, Error>;

package/dist/types/api/queryKeys.d.ts

@@ -3,8 +3,9 @@ import type { QueryKeyRetrieveAddress } from './address/useRetrieveAddress';
 import type { QueryKeySearchAddress } from './address/useSearchAddress';
 import type { QueryKeyBusinessLines } from './businessLines/useBusinessLines';
 import type { QueryKeyCheckAsAService } from './check/useCheck';
-import type { QueryKeyCompanyDataset } from './companyDataSet/useCompanyDataset';
+import type { QueryKeyCompanyDataset } from './companyDataSet/handleCompanyDataset';
 import type { QueryKeyCompanySearch } from './companySearch/useCompanySearch';
+import type { QueryKeyCompanySelection } from './companySelection/useCompanySelection';
 import type { QueryKeyScenarios } from './configurations/useScenarios';
 import type { QueryKeySupportedCountries } from './configurations/useSupportedCountries';
 import type { QueryKeyTaskTypes } from './configurations/useTaskTypes';
@@ -13,6 +14,7 @@ import type { QueryKeyLegalForms } from './datasets/useLegalForms';
 import type { QueryKeyNaceCodes } from './datasets/useNaceCodes';
 import type { QueryKeySourceOfFundsTypes } from './datasets/useSourceOfFundsTypes';
 import type { QueryKeyDocument } from './documents/useDocument';
+import type { QueryKeyIdNowProviderIdentificationStatus, QueryKeyIdNowProviderStartIdentification } from './idNowProvider/useIdNowProvider';
 import type { QueryKeyIdVerificationToken } from './idVerificationProviders/useIdVerificationToken';
 import type { QueryKeyLegalEntity } from './legalEntity/useLegalEntity';
 import type { QueryKeyOnboardingStatus } from './onboardingStatus/useOnboardingStatus';
@@ -28,13 +30,13 @@ import type { QueryKeyTermsOfService } from './termsOfService/useTermsOfService'
 import type { QueryKeyTermsOfServiceAcceptanceInfos } from './termsOfService/useTermsOfServiceAcceptanceInfos';
 import type { QueryKeyTermsOfServiceStatus } from './termsOfService/useTermsOfServiceStatus';
 import type { QueryKeyVerifyTin } from './tinVerification/useVerifyTin';
-import type { QueryKeyBankVerificationProviders } from './transferInstruments/useBankVerificationProviders';
+import type { QueryKeyBankVerificationProviders } from './transferInstruments/transferInstruments.types';
 import type { QueryKeyTransferInstrument } from './transferInstruments/useTransferInstrument';
 import type { QueryKeyTransferInstruments } from './transferInstruments/useTransferInstruments';
 import type { QueryKeyAnalyticsSession } from './uiAnalytics/useAnalyticsSession';
 import type { QueryKeyValidatePhoneNumber } from './validation/useValidatePhoneNumber';
 type SkippedQuery = [];
-export type QueryKey = SkippedQuery | QueryKeyLegalEntity | QueryKeyAnalyticsSession | QueryKeyPciQuestionnaireList | QueryKeyAddressCleanse | QueryKeyRetrieveAddress | QueryKeySearchAddress | QueryKeyBusinessLines | QueryKeyCheckAsAService | QueryKeyScenarios | QueryKeySupportedCountries | QueryKeyTaskTypes | QueryKeyVersionConfiguration | QueryKeyLegalForms | QueryKeyDocument | QueryKeyOnboardingStatus | QueryKeySourceOfFundsTypes | QueryKeyOpenIdAuthorizationLink | QueryKeyBankVerificationProviders | QueryKeyTransferInstrument | QueryKeyTransferInstruments | QueryKeyPciStatus | QueryKeyPciTemplate | QueryKeyProvidersStatus | QueryKeyTermsOfService | QueryKeyTermsOfServiceAcceptanceInfos | QueryKeyTermsOfServiceStatus | QueryKeyTaskStatus | QueryKeyTaxClassification | QueryKeyNaceCodes | QueryKeyValidatePhoneNumber | QueryKeyAcceptedTermsOfService | QueryKeyIdVerificationToken | QueryKeyVerifyTin | QueryKeyCompanyDataset | QueryKeyCompanySearch;
+export type QueryKey = QueryKeyAcceptedTermsOfService | QueryKeyAddressCleanse | QueryKeyAnalyticsSession | QueryKeyBankVerificationProviders | QueryKeyBusinessLines | QueryKeyCheckAsAService | QueryKeyCompanyDataset | QueryKeyCompanySearch | QueryKeyCompanySelection | QueryKeyDocument | QueryKeyIdNowProviderIdentificationStatus | QueryKeyIdNowProviderStartIdentification | QueryKeyIdVerificationToken | QueryKeyLegalEntity | QueryKeyLegalForms | QueryKeyNaceCodes | QueryKeyOnboardingStatus | QueryKeyOpenIdAuthorizationLink | QueryKeyPciQuestionnaireList | QueryKeyPciStatus | QueryKeyPciTemplate | QueryKeyProvidersStatus | QueryKeyRetrieveAddress | QueryKeyScenarios | QueryKeySearchAddress | QueryKeySourceOfFundsTypes | QueryKeySupportedCountries | QueryKeyTaskStatus | QueryKeyTaskTypes | QueryKeyTaxClassification | QueryKeyTermsOfService | QueryKeyTermsOfServiceAcceptanceInfos | QueryKeyTermsOfServiceStatus | QueryKeyTransferInstrument | QueryKeyTransferInstruments | QueryKeyValidatePhoneNumber | QueryKeyVerifyTin | QueryKeyVersionConfiguration | SkippedQuery;
 declare module '@tanstack/react-query' {
     interface Register {
         queryKey: QueryKey;

package/dist/types/api/taskStatus/taskStatus.types.d.ts

@@ -0,0 +1,4 @@
+import type { SetRequired } from 'type-fest';
+import type { components } from '#api/taskStatus/taskStatus.contract';
+export type TaskStatusEntry = SetRequired<components['schemas']['TaskStatusEntryDto'], 'status' | 'id'>;
+export type ApiTaskStatus = components['schemas']['TaskStatus'];

package/dist/types/api/taskStatus/useTaskStatus.d.ts

@@ -1,9 +1,6 @@
 import type { QueryOptions } from '../../../types';
 import type { TaskStatusApiResponse } from '../../stores/globalStore/taskStatus';
-import type { components } from './taskStatus.contract';
-export type ApiTaskStatus = components['schemas']['TaskStatus'];
 export type QueryKeyTaskStatus = ['taskStatus'];
-export type { TaskStatusEntry } from './taskStatus.contract.overrides';
 /**
  * @param options additional options passed to Tanstack Query, eg; refetchInterval for polling
  */

package/dist/types/api/taxClassification/taxClassification.types.d.ts

@@ -0,0 +1,2 @@
+import type { components } from './taxClassification.contract';
+export type TaxClassificationSuccessResponse = components['schemas']['TaxReportingClassification'];

package/dist/types/api/taxClassification/useTaxClassification.d.ts

@@ -1,6 +1,5 @@
 import type { QueryOptions } from '../types';
-import type { components } from './taxClassification.contract';
-export type TaxClassificationSuccessResponse = components['schemas']['TaxReportingClassification'];
+import type { TaxClassificationSuccessResponse } from './taxClassification.types';
 export type QueryKeyTaxClassification = ['taxClassification'];
 /**
  * @param options additional options passed to Tanstack Query, eg; refetchInterval for polling

package/dist/types/api/termsOfService/termsOfService.types.d.ts

@@ -0,0 +1,10 @@
+import type { ServiceAgreementSignResponse } from '../../core/models/api/contracts';
+import type { EndpointFromPaths } from '../types';
+import type { components, paths } from './termsOfService.contract';
+type TermsOfServiceEndpoints = EndpointFromPaths<keyof paths>;
+export type AcceptedTermsOfServiceEndpoint = Extract<TermsOfServiceEndpoints, `legalEntities/${string}/termsOfService/acceptedTermsOfServiceDocument/${string}`>;
+export type AcceptedTermsOfServiceResponse = components['schemas']['GetAcceptedTermsOfServiceDocumentResponse'];
+export type AcceptTermsOfServiceAcceptEndpoint = Extract<TermsOfServiceEndpoints, `legalEntities/${string}/termsOfService/accept`>;
+export type AcceptTermsOfServiceAcceptRequest = components['schemas']['AcceptTermsOfServiceRequest'];
+export type AcceptTermsOfServiceAcceptResponse = ServiceAgreementSignResponse;
+export {};

package/dist/types/api/termsOfService/useAcceptTermsOfService.d.ts

@@ -1,15 +1,8 @@
 import { type MutationOptions } from '@tanstack/react-query';
-import type { components, paths } from '#api/termsOfService/termsOfService.contract';
-import type { ServiceAgreementSignResponse } from '../../core/models/api/contracts';
-import type { EndpointFromPaths } from '../types';
-type TermsOfServiceEndpoints = EndpointFromPaths<keyof paths>;
-export type TermsOfServiceAcceptEndpoint = Extract<TermsOfServiceEndpoints, `legalEntities/${string}/termsOfService/accept`>;
-type Request = components['schemas']['AcceptTermsOfServiceRequest'];
-type SuccessResponse = ServiceAgreementSignResponse;
-export declare const acceptTermsOfService: (legalEntityId: string, baseUrl: string, termsOfServiceDocumentId: string, data: Request) => Promise<SuccessResponse>;
-export declare const useAcceptTermsOfService: (options?: Omit<MutationOptions<SuccessResponse, unknown, Request>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<ServiceAgreementSignResponse, unknown, {
+import type { AcceptTermsOfServiceAcceptRequest, AcceptTermsOfServiceAcceptResponse } from './termsOfService.types';
+export declare const acceptTermsOfService: (legalEntityId: string, baseUrl: string, termsOfServiceDocumentId: string, data: AcceptTermsOfServiceAcceptRequest) => Promise<import("../../core/models/api/contracts").ServiceAgreementSignResponse>;
+export declare const useAcceptTermsOfService: (options?: Omit<MutationOptions<AcceptTermsOfServiceAcceptResponse, unknown, AcceptTermsOfServiceAcceptRequest>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<import("../../core/models/api/contracts").ServiceAgreementSignResponse, unknown, {
     acceptedBy: string;
     legalEntityReference: string;
     termsOfServiceDocumentId: string;
 }, unknown>;
-export {};

package/dist/types/api/termsOfService/useAcceptedTermsOfService.d.ts

@@ -1,9 +1,6 @@
 import type { TermsOfServiceDocumentFormat } from '../../core/models/api/contracts';
-import type { EndpointFromPaths, QueryOptions } from '../types';
-import type { components, paths } from './termsOfService.contract';
-type TermsOfServiceEndpoints = EndpointFromPaths<keyof paths>;
-export type TermsOfServiceAcceptedEndpoint = Extract<TermsOfServiceEndpoints, `legalEntities/${string}/termsOfService/acceptedTermsOfServiceDocument/${string}`>;
-export type SuccessResponse = components['schemas']['GetAcceptedTermsOfServiceDocumentResponse'];
+import type { QueryOptions } from '../types';
+import type { AcceptedTermsOfServiceResponse } from './termsOfService.types';
 /**
  * Variables:
  * * `termsOfServiceAcceptanceReference`
@@ -13,11 +10,15 @@ export type QueryKeyAcceptedTermsOfService = [
     string | undefined,
     TermsOfServiceDocumentFormat
 ];
-export declare const getAcceptedTermsOfService: (legalEntityId: string, baseUrl: string, termsOfServiceAcceptanceReference: string, documentFormat: TermsOfServiceDocumentFormat) => Promise<SuccessResponse>;
-export declare const useAcceptedTermsOfService: (termsOfServiceAcceptanceReference: string | undefined, documentFormat: TermsOfServiceDocumentFormat, options?: QueryOptions<SuccessResponse>) => import("@tanstack/react-query").UseQueryResult<{
+export declare const getAcceptedTermsOfService: (legalEntityId: string, baseUrl: string, termsOfServiceAcceptanceReference: string, documentFormat: TermsOfServiceDocumentFormat) => Promise<{
+    document?: string;
+    id?: string;
+    termsOfServiceAcceptanceReference?: string;
+    termsOfServiceDocumentFormat?: "JSON" | "PDF";
+}>;
+export declare const useAcceptedTermsOfService: (termsOfServiceAcceptanceReference: string | undefined, documentFormat: TermsOfServiceDocumentFormat, options?: QueryOptions<AcceptedTermsOfServiceResponse>) => import("@tanstack/react-query").UseQueryResult<{
     document?: string;
     id?: string;
     termsOfServiceAcceptanceReference?: string;
     termsOfServiceDocumentFormat?: "JSON" | "PDF";
 }, Error>;
-export {};

package/dist/types/api/termsOfService/useTermsOfService.d.ts

@@ -1,12 +1,19 @@
 import type { EndpointFromPaths, QueryOptions } from '../types';
 import type { components, paths } from './termsOfService.contract';
-export type Request = components['schemas']['TermsOfServiceDocumentRequest'];
-export type SuccessResponse = components['schemas']['TermsOfServiceDocumentResponse'];
+export type TermsOfServiceRequest = components['schemas']['TermsOfServiceDocumentRequest'];
+export type TermsOfServiceResponse = components['schemas']['TermsOfServiceDocumentResponse'];
 type TermsOfServiceEndpoints = EndpointFromPaths<keyof paths>;
 export type TermsOfServiceEndpoint = Extract<TermsOfServiceEndpoints, `legalEntities/${string}/termsOfService`>;
-export type QueryKeyTermsOfService = ['termsOfService', Request];
-export declare const getTermsOfService: (legalEntityId: string, baseUrl: string, data: Request) => Promise<SuccessResponse>;
-export declare const useTermsOfService: (data: Request, options?: QueryOptions<SuccessResponse>) => import("@tanstack/react-query").UseQueryResult<{
+export type QueryKeyTermsOfService = ['termsOfService', TermsOfServiceRequest];
+export declare const getTermsOfService: (legalEntityId: string, baseUrl: string, data: TermsOfServiceRequest) => Promise<{
+    document?: string;
+    id?: string;
+    language?: string;
+    termsOfServiceDocumentFormat?: string;
+    termsOfServiceDocumentId?: string;
+    type?: components["schemas"]["TermsOfServiceType"];
+}>;
+export declare const useTermsOfService: (data: TermsOfServiceRequest, options?: QueryOptions<TermsOfServiceResponse>) => import("@tanstack/react-query").UseQueryResult<{
     document?: string;
     id?: string;
     language?: string;

package/dist/types/api/termsOfService/useTermsOfServiceAcceptanceInfos.d.ts

@@ -3,7 +3,7 @@ import type { EndpointFromPaths, QueryOptions } from '../types';
 import type { paths } from './termsOfService.contract';
 type TermsOfServiceEndpoints = EndpointFromPaths<keyof paths>;
 export type TermsOfServiceAcceptanceInfoEndpoint = Extract<TermsOfServiceEndpoints, `legalEntities/${string}/termsOfService/termsOfServiceAcceptanceInfos`>;
-type SuccessResponse = ServiceAgreementAcceptanceInfos;
+type AcceptanceInfosResponse = ServiceAgreementAcceptanceInfos;
 export type QueryKeyTermsOfServiceAcceptanceInfos = ['termsOfServiceAcceptanceInfos'];
-export declare const useTermsOfServiceAcceptanceInfos: (options?: QueryOptions<SuccessResponse>) => import("@tanstack/react-query").UseQueryResult<ServiceAgreementAcceptanceInfos, Error>;
+export declare const useTermsOfServiceAcceptanceInfos: (options?: QueryOptions<AcceptanceInfosResponse>) => import("@tanstack/react-query").UseQueryResult<ServiceAgreementAcceptanceInfos, Error>;
 export {};

package/dist/types/api/termsOfService/useTermsOfServiceStatus.d.ts

@@ -1,10 +1,10 @@
 import type { EndpointFromPaths, QueryOptions } from '../types';
 import type { components, paths } from './termsOfService.contract';
-export type SuccessResponse = components['schemas']['TermsOfServiceStatusResponse'];
+export type TermsOfServiceStatusResponse = components['schemas']['TermsOfServiceStatusResponse'];
 type TermsOfServiceEndpoints = EndpointFromPaths<keyof paths>;
 export type TermsOfServiceStatusEndpoint = Extract<TermsOfServiceEndpoints, `legalEntities/${string}/termsOfService/termsOfServiceStatus`>;
 export type QueryKeyTermsOfServiceStatus = ['termsOfServiceStatus'];
-export declare const useTermsOfServiceStatus: (options?: QueryOptions<SuccessResponse>) => import("@tanstack/react-query").UseQueryResult<{
+export declare const useTermsOfServiceStatus: (options?: QueryOptions<TermsOfServiceStatusResponse>) => import("@tanstack/react-query").UseQueryResult<{
     termsOfServiceTypes?: components["schemas"]["TermsOfServiceType"][];
 }, Error>;
 export {};

package/dist/types/api/tinVerification/tinVerification.types.d.ts

@@ -0,0 +1,4 @@
+import type { components } from './tinVerification.contract';
+export type TinVerificationResponse = components['schemas']['CompanyTinVerificationResponse'];
+export type TinVerificationRequest = components['schemas']['CompanyTinVerificationRequest'];
+export type VerifyTin = (data: TinVerificationRequest) => Promise<TinVerificationResponse>;

package/dist/types/api/tinVerification/useVerifyTin.d.ts

@@ -1,9 +1,7 @@
 import type { QueryOptions } from '../types';
-import type { components } from './tinVerification.contract';
+import type { TinVerificationRequest, TinVerificationResponse } from './tinVerification.types';
 export type QueryKeyVerifyTin = ['verifyTin', TinVerificationRequest | undefined];
-export type TinVerificationResponse = components['schemas']['CompanyTinVerificationResponse'];
-export type TinVerificationRequest = components['schemas']['CompanyTinVerificationRequest'];
-export type VerifyTin = (data: TinVerificationRequest) => Promise<TinVerificationResponse>;
 export declare const useVerifyTin: (data?: TinVerificationRequest, options?: QueryOptions<TinVerificationResponse>) => import("@tanstack/react-query").UseQueryResult<{
     matched?: boolean;
 }, Error>;
+export declare const verifyTin: (legalEntityId: string, baseUrl: string, data: TinVerificationRequest) => Promise<TinVerificationResponse>;

package/dist/types/api/transferInstruments/transferInstruments.types.d.ts

@@ -0,0 +1,25 @@
+import type { Language } from '../../language/Language';
+import type { CountryCode } from '../../types/datasets/country-code';
+import type { components, operations } from './transferInstruments.contract';
+export type GetBankVerificationProviderResponse = components['schemas']['BankAggregatorProviderResponse'][];
+export type BankVerificationVendor = GetBankVerificationProviderResponse[number];
+export type GetBankVerificationQueryParams = operations['getBankVerificationProviders']['parameters']['query'] & {
+    country: CountryCode;
+    locale: Language['locale'];
+};
+export type QueryKeyBankVerificationProviders = [
+    'bankVerificationProviders',
+    GetBankVerificationQueryParams
+];
+export type CreateTrustedTransferInstrumentResponse = components['schemas']['BankVerificationResponse'];
+export type CreateTrustedTransferInstrumentRequest = components['schemas']['CreateTrustedTransferInstrumentRequest'];
+export type BankVerificationErrorRequest = components['schemas']['BankVerificationErrorRequest'];
+export type BankVerificationErrorResponse = components['schemas']['BankVerificationResponse'];
+export type GetTransferInstrumentResponse = components['schemas']['TransferInstrumentOverview'][];
+export type TransferInstrumentReference = components['schemas']['TransferInstrumentOverview'];
+export type TransferInstrumentReferenceWithStatusId = Omit<TransferInstrumentReference, 'transferInstrument' | 'status'> & {
+    status: NonNullable<components['schemas']['TransferInstrumentOverview']['status']>;
+    transferInstrument: Omit<components['schemas']['TransferInstrumentReferenceDto'], 'id'> & {
+        id: string;
+    };
+};

package/dist/types/api/transferInstruments/useBankVerificationProviders.d.ts

@@ -1,17 +1,5 @@
-import type { Language } from '../../language/Language';
-import type { CountryCode } from '../../core/models/country-code';
 import type { QueryOptions } from '../types';
-import type { components, operations } from './transferInstruments.contract';
-type GetBankVerificationProviderResponse = components['schemas']['BankAggregatorProviderResponse'][];
-export type BankVerificationVendor = GetBankVerificationProviderResponse[number];
-export type GetBankVerificationQueryParams = operations['getBankVerificationProviders']['parameters']['query'] & {
-    country: CountryCode;
-    locale: Language['locale'];
-};
-export type QueryKeyBankVerificationProviders = [
-    'bankVerificationProviders',
-    GetBankVerificationQueryParams
-];
+import type { GetBankVerificationProviderResponse, GetBankVerificationQueryParams } from './transferInstruments.types';
 /**
  * Retrieves the list of bank verification providers and their respective urls.
  * Bank verification providers are used to instantly verify payout accounts.
@@ -19,4 +7,3 @@ export type QueryKeyBankVerificationProviders = [
  * @param options additional options passed to Tanstack Query, eg; onSuccess
  */
 export declare const useBankVerificationProviders: (queryParams: GetBankVerificationQueryParams, options?: QueryOptions<GetBankVerificationProviderResponse>) => import("@tanstack/react-query").UseQueryResult<GetBankVerificationProviderResponse, Error>;
-export {};

package/dist/types/api/transferInstruments/useCreateTrustedTransferInstrument.d.ts

@@ -1,13 +1,11 @@
 import type { MutationOptions } from '../types';
-import type { components } from './transferInstruments.contract';
-export type CreateTrustedTransferInstrumentResponse = components['schemas']['BankVerificationResponse'];
-type CreateTrustedTransferInstrumentRequestData = components['schemas']['CreateTrustedTransferInstrumentRequest'];
+import type { CreateTrustedTransferInstrumentRequest, CreateTrustedTransferInstrumentResponse } from './transferInstruments.types';
 /**
  * Creates a trusted transfer instrument in LEM using the information provided by Open Banking
  * @param options additional options passed to Tanstack Query, eg; onSuccess
  */
-export declare const useCreateTrustedTransferInstrument: (options?: MutationOptions<CreateTrustedTransferInstrumentResponse, Error, CreateTrustedTransferInstrumentRequestData>) => import("@tanstack/react-query").UseMutationResult<{
-    accounts?: components["schemas"]["BankAccountSummary"][];
+export declare const useCreateTrustedTransferInstrument: (options?: MutationOptions<CreateTrustedTransferInstrumentResponse, Error, CreateTrustedTransferInstrumentRequest>) => import("@tanstack/react-query").UseMutationResult<{
+    accounts?: import("./transferInstruments.contract").components["schemas"]["BankAccountSummary"][];
     error?: string;
     errorMessage?: string;
     verificationReference?: string;
@@ -15,4 +13,3 @@ export declare const useCreateTrustedTransferInstrument: (options?: MutationOpti
     code: string;
     state: string;
 }, unknown>;
-export {};

package/dist/types/api/transferInstruments/useHandleBankVerificationError.d.ts

@@ -1,13 +1,11 @@
-import type { MutationOptions } from '../types.js';
-import type { components } from './transferInstruments.contract';
-type BankVerificationErrorRequestBody = components['schemas']['BankVerificationErrorRequest'];
-export type BankVerificationErrorResponse = components['schemas']['BankVerificationResponse'];
+import type { MutationOptions } from '../types';
+import type { BankVerificationErrorRequest, BankVerificationErrorResponse } from './transferInstruments.types';
 /**
  * Receives an error code and message from a banking verification provider and translates it to a known, standardized error
  * @param options additional mutation options
  */
-export declare const useHandleBankVerificationError: (options?: MutationOptions<BankVerificationErrorResponse, unknown, BankVerificationErrorRequestBody>) => import("@tanstack/react-query").UseMutationResult<{
-    accounts?: components["schemas"]["BankAccountSummary"][];
+export declare const useHandleBankVerificationError: (options?: MutationOptions<BankVerificationErrorResponse, unknown, BankVerificationErrorRequest>) => import("@tanstack/react-query").UseMutationResult<{
+    accounts?: import("./transferInstruments.contract").components["schemas"]["BankAccountSummary"][];
     error?: string;
     errorMessage?: string;
     verificationReference?: string;
@@ -19,4 +17,3 @@ export declare const useHandleBankVerificationError: (options?: MutationOptions<
     };
     state: string;
 }, unknown>;
-export {};

package/dist/types/api/transferInstruments/useTransferInstruments.d.ts

@@ -1,13 +1,5 @@
 import type { QueryOptions } from '../types';
-import type { components } from './transferInstruments.contract';
-export type GetTransferInstrumentResponse = components['schemas']['TransferInstrumentOverview'][];
-export type TransferInstrumentReference = components['schemas']['TransferInstrumentOverview'];
-export type TransferInstrumentReferenceWithStatusId = Omit<TransferInstrumentReference, 'transferInstrument' | 'status'> & {
-    status: NonNullable<components['schemas']['TransferInstrumentOverview']['status']>;
-    transferInstrument: Omit<components['schemas']['TransferInstrumentReferenceDto'], 'id'> & {
-        id: string;
-    };
-};
+import type { GetTransferInstrumentResponse } from './transferInstruments.types';
 export type QueryKeyTransferInstruments = ['transferInstruments'];
 /**
  * Gets a list of transfer instruments associated with a legal entity

package/dist/types/api/uiAnalytics/uiAnalytics.types.d.ts

@@ -0,0 +1,7 @@
+import type { SetRequired } from 'type-fest';
+import type { MixpanelProperty } from '../../core/user-events';
+import type { components } from './analytics.contract';
+export type AnalyticsSessionResponse = SetRequired<components['schemas']['InitSessionResponse'], 'id'>;
+export type AnalyticsSessionRequest = Omit<components['schemas']['InitSessionRequest'], 'userData'> & {
+    userData: Record<string, MixpanelProperty>;
+};

package/dist/types/api/uiAnalytics/useAnalyticsSession.d.ts

@@ -1,22 +1,10 @@
 import { type QueryOptions } from '@tanstack/react-query';
-import type { SetRequired } from 'type-fest';
-import type { MixpanelProperty } from '../../core/user-events';
-import type { components } from './analytics.contract';
-type SuccessResponse = components['schemas']['InitSessionResponse'];
-type CorrectedSuccessResponse = SetRequired<SuccessResponse, 'id'>;
-export interface SessionData {
-    sdkVersion: string;
-    componentName: string;
-    userAgent: string;
-    legalEntityId: string;
-    userData?: Record<string, MixpanelProperty>;
-}
+import type { AnalyticsSessionRequest, AnalyticsSessionResponse } from './uiAnalytics.types';
 /**
  * Variables:
  * * `onboardingVersion`
  */
 export type QueryKeyAnalyticsSession = ['analyticsSession', number | undefined];
-export declare const useAnalyticsSession: (sessionData: SessionData, onboardingVersion: number | undefined, options?: QueryOptions<CorrectedSuccessResponse>) => import("@tanstack/react-query").UseQueryResult<{
+export declare const useAnalyticsSession: (sessionData: AnalyticsSessionRequest, onboardingVersion: number | undefined, options?: QueryOptions<AnalyticsSessionResponse>) => import("@tanstack/react-query").UseQueryResult<{
     id: string;
 }, Error>;
-export {};

package/dist/types/api/uiAnalytics/usePushAnalyticEvent.d.ts

@@ -1,8 +1,8 @@
 import { type MutationOptions } from '@tanstack/react-query';
 import type { components } from './analytics.contract';
-type SuccessResponse = components['schemas']['JsonNode'];
+type PushAnalyticEventResponse = components['schemas']['JsonNode'];
 type Request = components['schemas']['LogAnalyticRequest'];
-export declare const usePushAnalyticEvent: (sessionId: string, options?: Omit<MutationOptions<SuccessResponse, unknown, Request>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<Record<string, never>, unknown, {
+export declare const usePushAnalyticEvent: (sessionId: string, options?: Omit<MutationOptions<PushAnalyticEventResponse, unknown, Request>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<Record<string, never>, unknown, {
     componentName: string;
     eventData?: {
         [key: string]: components["schemas"]["JsonNode"];

package/dist/types/api/validation/useValidateAccountIdentification.d.ts

@@ -1,10 +1,5 @@
 import type { MutationOptions } from '@tanstack/react-query';
-import type { SetRequired } from 'type-fest';
 import type { AccountIdentification } from '../../core/models/api/accountIdentification';
-import type { components } from './validation.contract';
-export type InvalidField = SetRequired<components['schemas']['InvalidField'], 'name'>;
-export type AccountValidationResponse = Omit<components['schemas']['ValidationResponse'], 'invalidFields'> & {
-    invalidFields?: InvalidField[];
-};
+import type { AccountValidationResponse } from './validation.types';
 export declare const validateAccountIdentification: (baseUrl: string, data: AccountIdentification) => Promise<AccountValidationResponse>;
 export declare const useValidateAccountIdentification: (options?: Omit<MutationOptions<AccountValidationResponse, unknown, AccountIdentification>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<AccountValidationResponse, unknown, AccountIdentification, unknown>;