@cuenca-mx/cuenca-js 1.2.2 → 2.0.0-dev1

package/build/dts/resources/billPayments.d.ts

@@ -0,0 +1,34 @@
+import { BillPayment, ServiceProvider } from '../models';
+import { BillPaymentQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const BillPaymentResource_base: {
+    new (...args: any[]): {
+        one(query?: BillPaymentQuery): Promise<BillPayment>;
+        first(query?: BillPaymentQuery): Promise<BillPayment | null>;
+        count(query?: BillPaymentQuery): Promise<number>;
+        page(query?: BillPaymentQuery | undefined, cursor?: string | undefined): Promise<{
+            items: BillPayment[];
+            nextCursor: string | null;
+        }>;
+        all(query?: BillPaymentQuery): AsyncGenerator<BillPayment, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<BillPayment>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<BillPayment, BillPaymentQuery>;
+declare class BillPaymentResource extends BillPaymentResource_base {
+    constructor(client: Client);
+    serviceProvider(providerUri: string | null | undefined): Promise<ServiceProvider | null>;
+}
+export default BillPaymentResource;

package/build/dts/resources/bridgeAccounts.d.ts

@@ -0,0 +1,49 @@
+import { WireObject } from '../helpers/case';
+import { BridgeAccount } from '../models';
+import { UserUpdateRequest } from '../requests';
+import { BridgeAccountQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const BridgeAccountResource_base: {
+    new (...args: any[]): {
+        one(query?: BridgeAccountQuery): Promise<BridgeAccount>;
+        first(query?: BridgeAccountQuery): Promise<BridgeAccount | null>;
+        count(query?: BridgeAccountQuery): Promise<number>;
+        page(query?: BridgeAccountQuery | undefined, cursor?: string | undefined): Promise<{
+            items: BridgeAccount[];
+            nextCursor: string | null;
+        }>;
+        all(query?: BridgeAccountQuery): AsyncGenerator<BridgeAccount, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<BridgeAccount>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        _update(id: string, data: WireObject): Promise<BridgeAccount>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<BridgeAccount, BridgeAccountQuery>;
+declare class BridgeAccountResource extends BridgeAccountResource_base {
+    constructor(client: Client);
+    update({ userId, ...req }: UserUpdateRequest & {
+        userId?: string;
+    }): Promise<BridgeAccount>;
+    toParams(query: BridgeAccountQuery): WireObject;
+    toQueryString(query: BridgeAccountQuery): string;
+}
+export default BridgeAccountResource;

package/build/dts/resources/bridgeBankAccounts.d.ts

@@ -0,0 +1,33 @@
+import { BridgeBankAccount } from '../models';
+import { BridgeBankAccountQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const BridgeBankAccountResource_base: {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<BridgeBankAccount>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        one(query?: BridgeBankAccountQuery): Promise<BridgeBankAccount>;
+        first(query?: BridgeBankAccountQuery): Promise<BridgeBankAccount | null>;
+        count(query?: BridgeBankAccountQuery): Promise<number>;
+        page(query?: BridgeBankAccountQuery | undefined, cursor?: string | undefined): Promise<{
+            items: BridgeBankAccount[];
+            nextCursor: string | null;
+        }>;
+        all(query?: BridgeBankAccountQuery): AsyncGenerator<BridgeBankAccount, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<BridgeBankAccount, BridgeBankAccountQuery>;
+declare class BridgeBankAccountResource extends BridgeBankAccountResource_base {
+    constructor(client: Client);
+}
+export default BridgeBankAccountResource;

package/build/dts/resources/bridgeClabes.d.ts

@@ -0,0 +1,27 @@
+import { WireObject } from '../helpers/case';
+import { BridgeClabe } from '../models';
+import { BridgeQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const BridgeClabeResource_base: {
+    new (...args: any[]): {
+        one(query?: BridgeQuery): Promise<BridgeClabe>;
+        first(query?: BridgeQuery): Promise<BridgeClabe | null>;
+        count(query?: BridgeQuery): Promise<number>;
+        page(query?: BridgeQuery | undefined, cursor?: string | undefined): Promise<{
+            items: BridgeClabe[];
+            nextCursor: string | null;
+        }>;
+        all(query?: BridgeQuery): AsyncGenerator<BridgeClabe, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<BridgeClabe, BridgeQuery>;
+declare class BridgeClabeResource extends BridgeClabeResource_base {
+    constructor(client: Client);
+    toParams(query: BridgeQuery): WireObject;
+    toQueryString(query: BridgeQuery): string;
+}
+export default BridgeClabeResource;

package/build/dts/resources/bridgeTransactions.d.ts

@@ -0,0 +1,36 @@
+import { WireObject } from '../helpers/case';
+import { BridgeTransaction } from '../models';
+import { BridgeTransactionQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const BridgeTransactionResource_base: {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<BridgeTransaction>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        one(query?: BridgeTransactionQuery): Promise<BridgeTransaction>;
+        first(query?: BridgeTransactionQuery): Promise<BridgeTransaction | null>;
+        count(query?: BridgeTransactionQuery): Promise<number>;
+        page(query?: BridgeTransactionQuery | undefined, cursor?: string | undefined): Promise<{
+            items: BridgeTransaction[];
+            nextCursor: string | null;
+        }>;
+        all(query?: BridgeTransactionQuery): AsyncGenerator<BridgeTransaction, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<BridgeTransaction, BridgeTransactionQuery>;
+declare class BridgeTransactionResource extends BridgeTransactionResource_base {
+    constructor(client: Client);
+    toParams(query: BridgeTransactionQuery): WireObject;
+    toQueryString(query: BridgeTransactionQuery): string;
+}
+export default BridgeTransactionResource;

package/build/dts/resources/cardActivations.d.ts

@@ -0,0 +1,19 @@
+import { Card, CardActivation } from '../models';
+import { CardActivationRequest } from '../requests';
+import { Client, ResourceCtor } from './base';
+declare const CardActivationResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<CardActivation>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<CardActivation, import("../types").QueryParams>;
+declare class CardActivationResource extends CardActivationResource_base {
+    constructor(client: Client);
+    create(req: CardActivationRequest): Promise<CardActivation>;
+    card(cardUri: string | null | undefined): Promise<Card | null>;
+}
+export default CardActivationResource;

package/build/dts/resources/cardTransactions.d.ts

@@ -0,0 +1,34 @@
+import { Card, CardTransaction } from '../models';
+import { CardTransactionQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const CardTransactionResource_base: {
+    new (...args: any[]): {
+        one(query?: CardTransactionQuery): Promise<CardTransaction>;
+        first(query?: CardTransactionQuery): Promise<CardTransaction | null>;
+        count(query?: CardTransactionQuery): Promise<number>;
+        page(query?: CardTransactionQuery | undefined, cursor?: string | undefined): Promise<{
+            items: CardTransaction[];
+            nextCursor: string | null;
+        }>;
+        all(query?: CardTransactionQuery): AsyncGenerator<CardTransaction, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<CardTransaction>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<CardTransaction, CardTransactionQuery>;
+declare class CardTransactionResource extends CardTransactionResource_base {
+    constructor(client: Client);
+    relatedCard(relatedCardUri: string | null | undefined): Promise<Card | null>;
+}
+export default CardTransactionResource;

package/build/dts/resources/cardValidations.d.ts

@@ -0,0 +1,19 @@
+import { Card, CardValidation } from '../models';
+import { CardValidationRequest } from '../requests';
+import { Client, ResourceCtor } from './base';
+declare const CardValidationResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<CardValidation>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<CardValidation, import("../types").QueryParams>;
+declare class CardValidationResource extends CardValidationResource_base {
+    constructor(client: Client);
+    create(req: CardValidationRequest): Promise<CardValidation>;
+    card(cardUri: string | null | undefined): Promise<Card | null>;
+}
+export default CardValidationResource;

package/build/dts/resources/cards.d.ts

@@ -0,0 +1,63 @@
+import { Card } from '../models';
+import { CardsQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const CardResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<Card>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        _deactivate(id: string, data?: import("../helpers/case").WireObject): Promise<Card>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        one(query?: CardsQuery): Promise<Card>;
+        first(query?: CardsQuery): Promise<Card | null>;
+        count(query?: CardsQuery): Promise<number>;
+        page(query?: CardsQuery | undefined, cursor?: string | undefined): Promise<{
+            items: Card[];
+            nextCursor: string | null;
+        }>;
+        all(query?: CardsQuery): AsyncGenerator<Card, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<Card>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        _update(id: string, data: import("../helpers/case").WireObject): Promise<Card>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<Card, CardsQuery>;
+declare class CardResource extends CardResource_base {
+    constructor(client: Client);
+    create(userId: string, issuer: string, fundingType: string): Promise<Card>;
+    deactivate(cardId: string): Promise<Card>;
+    update(cardId: string, status: string, pinBlock?: string): Promise<Card>;
+}
+export default CardResource;

package/build/dts/resources/commissions.d.ts

@@ -0,0 +1,34 @@
+import { BillPayment, BridgeTransaction, CardTransaction, Commission, Deposit, Saving, Transfer, WalletTransaction, WhatsAppTransfer } from '../models';
+import { Client, ResourceCtor } from './base';
+type RelatedTransaction = BillPayment | BridgeTransaction | CardTransaction | Deposit | Saving | Transfer | WalletTransaction | WhatsAppTransfer;
+declare const CommissionResource_base: {
+    new (...args: any[]): {
+        one(query?: import("../types").QueryParams): Promise<Commission>;
+        first(query?: import("../types").QueryParams): Promise<Commission | null>;
+        count(query?: import("../types").QueryParams): Promise<number>;
+        page(query?: import("../types").QueryParams | undefined, cursor?: string | undefined): Promise<{
+            items: Commission[];
+            nextCursor: string | null;
+        }>;
+        all(query?: import("../types").QueryParams): AsyncGenerator<Commission, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<Commission>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<Commission, import("../types").QueryParams>;
+declare class CommissionResource extends CommissionResource_base {
+    constructor(client: Client);
+    relatedTransaction(relatedTransactionUri: string): Promise<RelatedTransaction | null>;
+}
+export default CommissionResource;

package/build/dts/resources/deposits.d.ts

@@ -0,0 +1,34 @@
+import { Account, Deposit } from '../models';
+import { DepositQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const DepositResource_base: {
+    new (...args: any[]): {
+        one(query?: DepositQuery): Promise<Deposit>;
+        first(query?: DepositQuery): Promise<Deposit | null>;
+        count(query?: DepositQuery): Promise<number>;
+        page(query?: DepositQuery | undefined, cursor?: string | undefined): Promise<{
+            items: Deposit[];
+            nextCursor: string | null;
+        }>;
+        all(query?: DepositQuery): AsyncGenerator<Deposit, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<Deposit>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<Deposit, DepositQuery>;
+declare class DepositResource extends DepositResource_base {
+    constructor(client: Client);
+    source(sourceUri: string): Promise<Account>;
+}
+export default DepositResource;

package/build/dts/resources/files.d.ts

@@ -0,0 +1,30 @@
+import { File as FileModel } from '../models';
+import { FileUploadRequest } from '../requests';
+import { Client, ResourceCtor } from './base';
+declare const FileResource_base: {
+    new (...args: any[]): {
+        _download(id: string, format?: unknown, responseType?: string | undefined): Promise<unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        _upload(data: import("../helpers/case").WireObject): Promise<FileModel>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<FileModel, import("../types").QueryParams>;
+declare class FileResource extends FileResource_base {
+    constructor(client: Client);
+    download(id: string, { responseType }?: {
+        responseType?: string;
+    }): Promise<unknown>;
+    upload(request: FileUploadRequest): Promise<FileModel>;
+}
+export default FileResource;

package/build/dts/resources/fraudFundsTransfers.d.ts

@@ -0,0 +1,18 @@
+import { FraudFundsTransfer } from '../models';
+import { FraudFundsTransferRequest } from '../requests';
+import { Client, ResourceCtor } from './base';
+declare const FraudFundsTransferResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<FraudFundsTransfer>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<FraudFundsTransfer, import("../types").QueryParams>;
+declare class FraudFundsTransferResource extends FraudFundsTransferResource_base {
+    constructor(client: Client);
+    create(req: FraudFundsTransferRequest): Promise<FraudFundsTransfer>;
+}
+export default FraudFundsTransferResource;

package/build/dts/resources/index.d.ts

@@ -0,0 +1,39 @@
+export { default as AccountResource } from './accounts';
+export { default as AlertResource } from './alerts';
+export { default as ApiKeyResource } from './apiKeys';
+export { default as ArpcResource } from './arpc';
+export { default as BalanceEntryResource } from './balanceEntries';
+export { default as BillPaymentResource } from './billPayments';
+export { default as BridgeAccountResource } from './bridgeAccounts';
+export { default as BridgeBankAccountResource } from './bridgeBankAccounts';
+export { default as BridgeClabeResource } from './bridgeClabes';
+export { default as BridgeTransactionResource } from './bridgeTransactions';
+export { default as CardActivationResource } from './cardActivations';
+export { default as CardResource } from './cards';
+export { default as CardTransactionResource } from './cardTransactions';
+export { default as CardValidationResource } from './cardValidations';
+export { default as CommissionResource } from './commissions';
+export { default as DepositResource } from './deposits';
+export { default as FileResource } from './files';
+export { default as FraudFundsTransferResource } from './fraudFundsTransfers';
+export { default as KYCValidationsResource } from './kycValidations';
+export { default as LegalPersonResource } from './legalPersons';
+export { default as LoginTokenResource } from './loginTokens';
+export { default as OperatorLoginResource } from './operatorLogins';
+export { default as OperatorResource } from './operators';
+export { default as PartnerResource } from './partners';
+export { default as PostalCodeResource } from './postalCodes';
+export { default as ReportResource } from './reports';
+export { default as SavingResource } from './savings';
+export { default as ServiceProviderResource } from './serviceProviders';
+export { default as SessionResource } from './sessions';
+export { default as StatementResource } from './statements';
+export { default as TransferResource } from './transfers';
+export { default as UserCredentialResource } from './userCredentials';
+export { default as UserLoginResource } from './userLogins';
+export { default as UserResource } from './users';
+export { default as UserReportResource } from './userReports';
+export { default as UsersTosAgreementsResource } from './usersTosAgreements';
+export { default as VerificationResource } from './verifications';
+export { default as WalletTransactionsResource } from './walletTransactions';
+export { default as WhatsAppTransferResource } from './whatsAppTransfers';

package/build/dts/resources/kycValidations.d.ts

@@ -0,0 +1,53 @@
+import { KYCValidations } from '../models';
+import { Client, ResourceCtor } from './base';
+declare const KYCValidationsResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<KYCValidations>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        _deactivate(id: string, data?: import("../helpers/case").WireObject): Promise<KYCValidations>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        one(query?: import("../types").QueryParams): Promise<KYCValidations>;
+        first(query?: import("../types").QueryParams): Promise<KYCValidations | null>;
+        count(query?: import("../types").QueryParams): Promise<number>;
+        page(query?: import("../types").QueryParams | undefined, cursor?: string | undefined): Promise<{
+            items: KYCValidations[];
+            nextCursor: string | null;
+        }>;
+        all(query?: import("../types").QueryParams): AsyncGenerator<KYCValidations, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<KYCValidations>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<KYCValidations, import("../types").QueryParams>;
+declare class KYCValidationsResource extends KYCValidationsResource_base {
+    private readonly isBridge;
+    constructor(client: Client, isBridge?: boolean);
+    create(userId?: string, force?: boolean): Promise<KYCValidations>;
+    deactivate(kycValidationId: string): Promise<KYCValidations>;
+}
+export default KYCValidationsResource;

package/build/dts/resources/legalPersons.d.ts

@@ -0,0 +1,54 @@
+import { LegalPerson } from '../models';
+import { LegalPersonRequest, LegalPersonUpdateRequest } from '../requests';
+import { QueryParams } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const LegalPersonResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<LegalPerson>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        one(query?: QueryParams): Promise<LegalPerson>;
+        first(query?: QueryParams): Promise<LegalPerson | null>;
+        count(query?: QueryParams): Promise<number>;
+        page(query?: QueryParams | undefined, cursor?: string | undefined): Promise<{
+            items: LegalPerson[];
+            nextCursor: string | null;
+        }>;
+        all(query?: QueryParams): AsyncGenerator<LegalPerson, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<LegalPerson>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        _update(id: string, data: import("../helpers/case").WireObject): Promise<LegalPerson>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & ResourceCtor<LegalPerson, QueryParams>;
+declare class LegalPersonResource extends LegalPersonResource_base {
+    constructor(client: Client);
+    create(req: LegalPersonRequest): Promise<LegalPerson>;
+    update(legalPersonId: string, req: LegalPersonUpdateRequest): Promise<LegalPerson>;
+}
+export default LegalPersonResource;

package/build/dts/resources/loginTokens.d.ts

@@ -0,0 +1,17 @@
+import { LoginToken } from '../models';
+import { Client, ResourceCtor } from './base';
+declare const LoginTokenResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<LoginToken>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<LoginToken, import("../types").QueryParams>;
+declare class LoginTokenResource extends LoginTokenResource_base {
+    constructor(client: Client);
+    create(): Promise<LoginToken>;
+}
+export default LoginTokenResource;

package/build/dts/resources/operatorLogins.d.ts

@@ -0,0 +1,19 @@
+import { OperatorLogin } from '../models';
+import { Client, ResourceCtor } from './base';
+declare const OperatorLoginResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<OperatorLogin>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: import("../types").QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: import("../types").QueryParams): string;
+    };
+} & ResourceCtor<OperatorLogin, import("../types").QueryParams>;
+declare class OperatorLoginResource extends OperatorLoginResource_base {
+    private sessionIdInHeaders;
+    constructor(client: Client);
+    create(email: string, password: string): Promise<OperatorLogin>;
+    clearSessionHeader(): void;
+}
+export default OperatorLoginResource;