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

package/build/dts/requests/userReportUpdateRequest.d.ts

@@ -0,0 +1,28 @@
+import { WireObject } from '../helpers/case';
+export interface UserReportUpdateRequest {
+    actividadEconomica?: string;
+    apellidoMaternoContraparte?: string;
+    apellidoPaternoContraparte?: string;
+    ciudadPoblacion?: string;
+    colonia?: string;
+    cuentaClabeContraparte?: string;
+    descripcionOperacion?: string;
+    entidadFederativaDomicilio?: string;
+    institucionFinancieraContraparte?: string;
+    instrumentoMonetario?: string;
+    mainAlertId?: string;
+    nacionalidadCuentaContraparte?: string;
+    nivelCuenta?: string;
+    nombreContraparte?: string;
+    paisNacionalidad?: string;
+    prioridadReporte?: string;
+    razonDenominacionContraparte?: string;
+    razonInusual?: string;
+    tipoOperacionItf?: string;
+    tipoOperacionPerfil?: string;
+    tipoPersonaContraparte?: string;
+}
+export declare const UserReportUpdateRequest: {
+    toObject: (req?: UserReportUpdateRequest) => WireObject;
+    toCleanObject: (req?: UserReportUpdateRequest) => WireObject;
+};

package/build/dts/requests/userRequest.d.ts

@@ -0,0 +1,39 @@
+import { WireObject } from '../helpers/case';
+import { AddressUpdateRequest } from './addressUpdateRequest';
+import { TosUpdateRequest } from './tosUpdateRequest';
+interface KycFileRequest {
+    data?: string;
+    isMx?: boolean;
+    status?: string;
+    type?: string;
+    uriBack?: string;
+    uriFront?: string;
+}
+export interface UserUpdateRequest {
+    address?: AddressUpdateRequest;
+    blacklistValidationStatus?: string;
+    countryOfBirth?: string;
+    curpDocumentUri?: string;
+    fiscalRegimeCode?: string;
+    govtId?: KycFileRequest;
+    emailAddress?: string;
+    isDormant?: boolean;
+    isFraud?: boolean;
+    isPldBlocked?: boolean;
+    isSecurityMode?: boolean;
+    profession?: string;
+    proofOfAddress?: KycFileRequest;
+    proofOfLife?: KycFileRequest;
+    requiredLevel?: number;
+    termsOfService?: TosUpdateRequest;
+    phoneNumber?: string;
+    rfc?: string;
+    status?: string;
+    userType?: string;
+    verificationId?: string;
+}
+export declare const UserUpdateRequest: {
+    toObject: (req?: UserUpdateRequest) => WireObject;
+    toCleanObject: (req?: UserUpdateRequest) => WireObject;
+};
+export {};

package/build/dts/requests/verificationRequest.d.ts

@@ -0,0 +1,17 @@
+import { WireObject } from '../helpers/case';
+export interface VerificationRequest {
+    platformId?: string;
+    recipient?: string;
+    type?: string;
+}
+export declare const VerificationRequest: {
+    toObject: (req?: VerificationRequest) => WireObject;
+    toCleanObject: (req?: VerificationRequest) => WireObject;
+};
+export interface VerificationAttemptRequest {
+    code?: string;
+}
+export declare const VerificationAttemptRequest: {
+    toObject: (req?: VerificationAttemptRequest) => WireObject;
+    toCleanObject: (req?: VerificationAttemptRequest) => WireObject;
+};

package/build/dts/requests/walletTransactionRequest.d.ts

@@ -0,0 +1,9 @@
+import { WireObject } from '../helpers/case';
+export interface WalletTransactionRequest {
+    amount: number;
+    transactionType?: string;
+    walletUri?: string;
+}
+export declare const WalletTransactionRequest: {
+    toObject: (req: WalletTransactionRequest) => WireObject;
+};

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

@@ -0,0 +1,33 @@
+import { Account } from '../models';
+import { AccountQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const AccountResource_base: {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<Account>;
+        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?: AccountQuery): Promise<Account>;
+        first(query?: AccountQuery): Promise<Account | null>;
+        count(query?: AccountQuery): Promise<number>;
+        page(query?: AccountQuery | undefined, cursor?: string | undefined): Promise<{
+            items: Account[];
+            nextCursor: string | null;
+        }>;
+        all(query?: AccountQuery): AsyncGenerator<Account, 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<Account, AccountQuery>;
+declare class AccountResource extends AccountResource_base {
+    constructor(client: Client);
+}
+export default AccountResource;

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

@@ -0,0 +1,54 @@
+import { Alert } from '../models';
+import { AlertUpdateRequest } from '../requests';
+import { AlertQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const AlertResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<Alert>;
+        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?: AlertQuery): Promise<Alert>;
+        first(query?: AlertQuery): Promise<Alert | null>;
+        count(query?: AlertQuery): Promise<number>;
+        page(query?: AlertQuery | undefined, cursor?: string | undefined): Promise<{
+            items: Alert[];
+            nextCursor: string | null;
+        }>;
+        all(query?: AlertQuery): AsyncGenerator<Alert, 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<Alert>;
+        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<Alert>;
+        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<Alert, AlertQuery>;
+declare class AlertResource extends AlertResource_base {
+    constructor(client: Client);
+    create(req: AlertUpdateRequest): Promise<Alert>;
+    update(alertId: string, req: AlertUpdateRequest): Promise<Alert>;
+}
+export default AlertResource;

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

@@ -0,0 +1,63 @@
+import { ApiKey } from '../models';
+import { ApiKeyQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const ApiKeyResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<ApiKey>;
+        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<ApiKey>;
+        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?: ApiKeyQuery): Promise<ApiKey>;
+        first(query?: ApiKeyQuery): Promise<ApiKey | null>;
+        count(query?: ApiKeyQuery): Promise<number>;
+        page(query?: ApiKeyQuery | undefined, cursor?: string | undefined): Promise<{
+            items: ApiKey[];
+            nextCursor: string | null;
+        }>;
+        all(query?: ApiKeyQuery): AsyncGenerator<ApiKey, 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<ApiKey>;
+        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<ApiKey>;
+        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<ApiKey, ApiKeyQuery>;
+declare class ApiKeyResource extends ApiKeyResource_base {
+    constructor(client: Client);
+    create(): Promise<ApiKey>;
+    deactivate(apiKeyId: string, minutes?: number): Promise<ApiKey>;
+    update(apiKeyId: string, metadata: Record<string, unknown>, userId?: string): Promise<ApiKey>;
+}
+export default ApiKeyResource;

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

@@ -0,0 +1,18 @@
+import { Arpc } from '../models';
+import { ArpcRequest } from '../requests';
+import { Client, ResourceCtor } from './base';
+declare const ArpcResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<Arpc>;
+        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<Arpc, import("../types").QueryParams>;
+declare class ArpcResource extends ArpcResource_base {
+    constructor(client: Client);
+    create(req: ArpcRequest): Promise<Arpc>;
+}
+export default ArpcResource;

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

@@ -0,0 +1,37 @@
+import { Account, BalanceEntry, BillPayment, BridgeAccount, Card, CardTransaction, Commission, Deposit, Saving, Transfer, WalletTransaction, WhatsAppTransfer } from '../models';
+import { BalanceEntryQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+type RelatedTransaction = BillPayment | CardTransaction | Commission | Deposit | Saving | Transfer | WalletTransaction | WhatsAppTransfer;
+type FundingInstrument = Account | BridgeAccount | Card;
+declare const BalanceEntryResource_base: {
+    new (...args: any[]): {
+        one(query?: BalanceEntryQuery): Promise<BalanceEntry>;
+        first(query?: BalanceEntryQuery): Promise<BalanceEntry | null>;
+        count(query?: BalanceEntryQuery): Promise<number>;
+        page(query?: BalanceEntryQuery | undefined, cursor?: string | undefined): Promise<{
+            items: BalanceEntry[];
+            nextCursor: string | null;
+        }>;
+        all(query?: BalanceEntryQuery): AsyncGenerator<BalanceEntry, 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<BalanceEntry>;
+        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<BalanceEntry, BalanceEntryQuery>;
+declare class BalanceEntryResource extends BalanceEntryResource_base {
+    constructor(client: Client);
+    relatedTransaction(relatedTransactionUri: string): Promise<RelatedTransaction | null>;
+    fundingInstrument(fundingInstrumentUri: string): Promise<FundingInstrument | RelatedTransaction | null>;
+}
+export default BalanceEntryResource;

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

@@ -0,0 +1,135 @@
+import { WireObject } from '../helpers/case';
+import { QueryParams } from '../types/queries/queryParams';
+export interface Client {
+    get(config: {
+        endpoint: string;
+        format?: unknown;
+        params?: WireObject;
+        headers?: Record<string, string>;
+        responseType?: string;
+    }): Promise<WireObject>;
+    post(config: {
+        endpoint: string;
+        data?: unknown;
+        multipart?: boolean;
+        headers?: Record<string, string>;
+        responseType?: string;
+    }): Promise<WireObject>;
+    patch(config: {
+        endpoint: string;
+        data?: unknown;
+        headers?: Record<string, string>;
+    }): Promise<WireObject>;
+    delete(config: {
+        endpoint: string;
+        data?: unknown;
+        headers?: Record<string, string>;
+    }): Promise<WireObject>;
+}
+export type ModelFactory<T> = (obj: WireObject) => T;
+type Constructor<T = object> = new (...args: any[]) => T;
+interface ResourceLike<T, Q extends QueryParams = QueryParams> {
+    client: Client;
+    path: string;
+    fromObject: ModelFactory<T>;
+    toParams(query: Q): WireObject;
+    toQueryString(query: Q): string;
+}
+export type ModelOf<TBase> = TBase extends Constructor<ResourceLike<infer T, QueryParams>> ? T : never;
+export type QueryOf<TBase> = TBase extends Constructor<ResourceLike<unknown, infer Q>> ? Q : QueryParams;
+export declare class Resource<T, Q extends QueryParams = QueryParams> {
+    readonly client: Client;
+    readonly path: string;
+    readonly fromObject: ModelFactory<T>;
+    constructor(client: Client, path: string, fromObject: ModelFactory<T>);
+    toParams(query: Q): WireObject;
+    toQueryString(query: Q): string;
+}
+export type ResourceCtor<T, Q extends QueryParams = QueryParams> = Constructor<Resource<T, Q>>;
+export declare function Retrievable<TBase extends Constructor<ResourceLike<unknown>>>(Base: TBase): {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<ModelOf<TBase>>;
+        client: Client;
+        path: string;
+        fromObject: ModelFactory<unknown>;
+        toParams(query: QueryParams): WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & TBase;
+export declare function Creatable<TBase extends Constructor<ResourceLike<unknown>>>(Base: TBase): {
+    new (...args: any[]): {
+        _create(data: WireObject): Promise<ModelOf<TBase>>;
+        client: Client;
+        path: string;
+        fromObject: ModelFactory<unknown>;
+        toParams(query: QueryParams): WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & TBase;
+export declare function Updateable<TBase extends Constructor<ResourceLike<unknown>>>(Base: TBase): {
+    new (...args: any[]): {
+        _update(id: string, data: WireObject): Promise<ModelOf<TBase>>;
+        client: Client;
+        path: string;
+        fromObject: ModelFactory<unknown>;
+        toParams(query: QueryParams): WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & TBase;
+export declare function Uploadable<TBase extends Constructor<ResourceLike<unknown>>>(Base: TBase): {
+    new (...args: any[]): {
+        _upload(data: WireObject): Promise<ModelOf<TBase>>;
+        client: Client;
+        path: string;
+        fromObject: ModelFactory<unknown>;
+        toParams(query: QueryParams): WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & TBase;
+export declare function Deactivable<TBase extends Constructor<ResourceLike<unknown>>>(Base: TBase): {
+    new (...args: any[]): {
+        _deactivate(id: string, data?: WireObject): Promise<ModelOf<TBase>>;
+        client: Client;
+        path: string;
+        fromObject: ModelFactory<unknown>;
+        toParams(query: QueryParams): WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & TBase;
+export declare function Downlodable<TBase extends Constructor<ResourceLike<unknown>>>(Base: TBase): {
+    new (...args: any[]): {
+        _download(id: string, format?: unknown, responseType?: string): Promise<unknown>;
+        client: Client;
+        path: string;
+        fromObject: ModelFactory<unknown>;
+        toParams(query: QueryParams): WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & TBase;
+export declare function Queryable<TBase extends Constructor<ResourceLike<unknown>>>(Base: TBase): {
+    new (...args: any[]): {
+        one(query?: QueryOf<TBase>): Promise<ModelOf<TBase>>;
+        first(query?: QueryOf<TBase>): Promise<ModelOf<TBase> | null>;
+        count(query?: QueryOf<TBase>): Promise<number>;
+        page(query?: QueryOf<TBase> | undefined, cursor?: string): Promise<{
+            items: ModelOf<TBase>[];
+            nextCursor: string | null;
+        }>;
+        all(query?: QueryOf<TBase>): AsyncGenerator<ModelOf<TBase>, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: ModelFactory<unknown>;
+        toParams(query: QueryParams): WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & TBase;
+/**
+ * Extracts the top-level path segment(s) from a resource URI, supporting nested paths
+ * (e.g. `/bridge/accounts/AC123` → `bridge/accounts`).
+ *
+ * NOT supported: sub-resource URIs like `/accounts/AC1/refund` — these return
+ * `accounts/AC1` which is not a valid resource key. If the API introduces
+ * sub-resources, extend this helper.
+ */
+export declare function getResourcePath(uri: string | null | undefined): string | null;
+export {};

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;