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

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

@@ -0,0 +1,100 @@
+import { WireObject } from '../helpers/case';
+import { AddressUpdateRequest } from './addressUpdateRequest';
+interface TransactionalProfileServicesRequest {
+    speiTransfersNum?: number;
+    speiTransfersAmount?: number;
+    internalTransfersNum?: number;
+    internalTransfersAmount?: number;
+}
+interface TransactionalProfileRequest {
+    currency?: string;
+    monthlyAmount?: number;
+    recipientsNum?: number;
+    payersNum?: number;
+    deposits?: TransactionalProfileServicesRequest;
+    withdrawal?: TransactionalProfileServicesRequest;
+}
+interface BusinessDetailsRequest {
+    accountUsageDescription?: string;
+    businessDescription?: string;
+}
+interface ShareholderPhysicalRequest {
+    names?: string;
+    curp?: string;
+    rfc?: string;
+    firstSurname?: string;
+    percentage?: number;
+    secondSurname?: string;
+    shareCapital?: number;
+}
+interface LegalRepresentativesRequest extends ShareholderPhysicalRequest {
+    address?: AddressUpdateRequest;
+    emailAddress?: string;
+    job?: string;
+    phoneNumber?: string;
+}
+interface ShareholderMoralRequest {
+    name?: string;
+    percentage?: number;
+    shareholders?: ShareholderPhysicalRequest[];
+    legalRepresentatives?: LegalRepresentativesRequest[];
+}
+interface VulnerableActivityRequest {
+    isVulnerableActivity?: boolean;
+    hasSatRegister?: boolean;
+    satRegisteredDate?: string;
+    isInCompliance?: boolean;
+}
+interface LicenseRequest {
+    licenseRequired?: boolean;
+    supervisoryEntity?: string;
+    licenseType?: string;
+    licenseDate?: string;
+}
+interface AuditRequest {
+    hasAudit?: boolean;
+    auditProvider?: string;
+    auditDate?: string;
+    auditComments?: string;
+}
+interface ExternalAccountRequest {
+    account?: string;
+    bank?: string;
+}
+export interface PartnerUserRequest {
+    address?: AddressUpdateRequest;
+    audit?: AuditRequest;
+    businessDetails?: BusinessDetailsRequest;
+    businessName?: string;
+    clabe?: string;
+    createdAt?: string;
+    documentationUrl?: string;
+    emailAddress?: string;
+    externalAccount?: ExternalAccountRequest;
+    folio?: string;
+    id?: string;
+    incorporationDate?: string;
+    legalName?: string;
+    legalRepresentatives?: LegalRepresentativesRequest[];
+    level?: number;
+    license?: LicenseRequest;
+    meta?: WireObject;
+    nationality?: string;
+    phoneNumber?: string;
+    platformId?: string;
+    requiredLevel?: number;
+    rfc?: string;
+    shareholders?: ShareholderMoralRequest[];
+    status?: string;
+    transactionalProfile?: TransactionalProfileRequest;
+    updatedAt?: string;
+    userId?: string;
+    userType?: string;
+    vulnerableActivity?: VulnerableActivityRequest;
+    webSite?: string;
+}
+export declare const PartnerUserRequest: {
+    toObject: (req?: PartnerUserRequest) => WireObject;
+    toCleanObject: (req?: PartnerUserRequest) => WireObject;
+};
+export {};

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

@@ -0,0 +1,8 @@
+import { WireObject } from '../helpers/case';
+export interface ReportGenerateRequest {
+    committeeMeetingDate?: string | null;
+}
+export declare const ReportGenerateRequest: {
+    toObject: (req?: ReportGenerateRequest) => WireObject;
+    toCleanObject: (req?: ReportGenerateRequest) => WireObject;
+};

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

@@ -0,0 +1,11 @@
+import { WireObject } from '../helpers/case';
+export interface SavingRequest {
+    category?: string;
+    goalAmount?: number;
+    goalDate?: Date | string;
+    name?: string;
+}
+export declare const SavingRequest: {
+    toObject: (req?: SavingRequest) => WireObject;
+    toCleanObject: (req?: SavingRequest) => WireObject;
+};

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

@@ -0,0 +1,12 @@
+import { WireObject } from '../helpers/case';
+export interface SessionRequest {
+    failureUrl?: string;
+    successUrl?: string;
+    type?: string;
+    userId?: string;
+    isBridge?: boolean;
+}
+export declare const SessionRequest: {
+    toObject: (req: SessionRequest) => WireObject;
+    toCleanObject: (req: SessionRequest) => WireObject;
+};

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

@@ -0,0 +1,11 @@
+import { WireObject } from '../helpers/case';
+export interface TosUpdateRequest {
+    ip: string;
+    location?: string;
+    type?: string;
+    version?: string;
+}
+export declare const TosUpdateRequest: {
+    toObject: (req: TosUpdateRequest) => WireObject;
+    toCleanObject: (req: TosUpdateRequest) => WireObject;
+};

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

@@ -0,0 +1,12 @@
+import { WireObject } from '../helpers/case';
+export interface TransferRequest {
+    accountNumber: string;
+    amount: number;
+    descriptor: string;
+    idempotencyKey?: string;
+    recipientName?: string;
+}
+export declare const TransferRequest: {
+    toObject: (req: TransferRequest) => WireObject;
+    toCleanObject: (req: TransferRequest) => WireObject;
+};

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

@@ -0,0 +1,8 @@
+import { WireObject } from '../helpers/case';
+export interface TransferUpdateRequest {
+    status?: string;
+}
+export declare const TransferUpdateRequest: {
+    toObject: (req?: TransferUpdateRequest) => WireObject;
+    toCleanObject: (req?: TransferUpdateRequest) => WireObject;
+};

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

@@ -0,0 +1,15 @@
+import { WireObject } from '../helpers/case';
+export interface UserCredentialRequest {
+    password: string;
+}
+export declare const UserCredentialRequest: {
+    toObject: (req: UserCredentialRequest) => WireObject;
+};
+export interface UserCredentialUpdateRequest {
+    password?: string | null;
+    isActive?: boolean;
+}
+export declare const UserCredentialUpdateRequest: {
+    toObject: (req: UserCredentialUpdateRequest) => WireObject;
+    toCleanObject: (req: UserCredentialUpdateRequest) => WireObject;
+};

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

@@ -0,0 +1,8 @@
+import { WireObject } from '../helpers/case';
+export interface UserLoginRequest {
+    password: string;
+    userId?: string;
+}
+export declare const UserLoginRequest: {
+    toObject: (req: UserLoginRequest) => WireObject;
+};

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

@@ -0,0 +1,9 @@
+import { WireObject } from '../helpers/case';
+export interface UserReportCreateRequest {
+    committeeMeetingDate?: string;
+    userId?: string | null;
+}
+export declare const UserReportCreateRequest: {
+    toObject: (req?: UserReportCreateRequest) => WireObject;
+    toCleanObject: (req?: UserReportCreateRequest) => WireObject;
+};

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 {};