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

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

@@ -0,0 +1,64 @@
+import { Account, Transfer } from '../models';
+import { TransferRequest, TransferUpdateRequest } from '../requests';
+import { TransferQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+interface CreateManyResult {
+    submitted: Transfer[];
+    errors: {
+        actualRequest: TransferRequest;
+        error: unknown;
+    }[];
+}
+declare const TransferResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<Transfer>;
+        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?: TransferQuery): Promise<Transfer>;
+        first(query?: TransferQuery): Promise<Transfer | null>;
+        count(query?: TransferQuery): Promise<number>;
+        page(query?: TransferQuery | undefined, cursor?: string | undefined): Promise<{
+            items: Transfer[];
+            nextCursor: string | null;
+        }>;
+        all(query?: TransferQuery): AsyncGenerator<Transfer, 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<Transfer>;
+        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<Transfer>;
+        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<Transfer, TransferQuery>;
+declare class TransferResource extends TransferResource_base {
+    constructor(client: Client);
+    destination(destinationUri: string): Promise<Account>;
+    create({ accountNumber, amount, descriptor, recipientName, idempotencyKey, }: TransferRequest): Promise<Transfer>;
+    update(transferId: string, req: TransferUpdateRequest): Promise<Transfer>;
+    createMany(requests: TransferRequest[] | undefined): Promise<CreateManyResult | Record<string, never>>;
+    static _genIdempotencyKey(accountNumber: string, amount: number): string;
+}
+export default TransferResource;

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

@@ -0,0 +1,30 @@
+import { UserCredential } from '../models';
+import { UserCredentialUpdateRequest } from '../requests';
+import { Client, ResourceCtor } from './base';
+declare const UserCredentialResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<UserCredential>;
+        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<UserCredential>;
+        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<UserCredential, import("../types").QueryParams>;
+declare class UserCredentialResource extends UserCredentialResource_base {
+    constructor(client: Client);
+    create(password: string): Promise<UserCredential>;
+    update({ isActive, password, userId, }: UserCredentialUpdateRequest & {
+        userId?: string;
+    }): Promise<UserCredential>;
+}
+export default UserCredentialResource;

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

@@ -0,0 +1,28 @@
+import { UserLogin } from '../models';
+import { Client, ResourceCtor } from './base';
+declare const UserLoginResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<UserLogin>;
+        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<UserLogin>;
+        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<UserLogin, import("../types").QueryParams>;
+declare class UserLoginResource extends UserLoginResource_base {
+    private loginIdInHeaders;
+    constructor(client: Client);
+    create(password: string, userId: string): Promise<UserLogin>;
+    logOut(userId?: string): Promise<boolean>;
+}
+export default UserLoginResource;

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

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

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

@@ -0,0 +1,56 @@
+import { User } from '../models';
+import { UserUpdateRequest } from '../requests';
+import { UserQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const UserResource_base: {
+    new (...args: any[]): {
+        _deactivate(id: string, data?: import("../helpers/case").WireObject): Promise<User>;
+        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?: UserQuery): Promise<User>;
+        first(query?: UserQuery): Promise<User | null>;
+        count(query?: UserQuery): Promise<number>;
+        page(query?: UserQuery | undefined, cursor?: string | undefined): Promise<{
+            items: User[];
+            nextCursor: string | null;
+        }>;
+        all(query?: UserQuery): AsyncGenerator<User, 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<User>;
+        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<User>;
+        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<User, UserQuery>;
+declare class UserResource extends UserResource_base {
+    constructor(client: Client);
+    update({ userId, ...req }: UserUpdateRequest & {
+        userId?: string;
+    }): Promise<User>;
+    deactivate(userId: string): Promise<User>;
+}
+export default UserResource;

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

@@ -0,0 +1,16 @@
+import { UserTosAgreement } from '../models';
+import { Client, ResourceCtor } from './base';
+declare const UsersTosAgreementsResource_base: {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<UserTosAgreement>;
+        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<UserTosAgreement, import("../types").QueryParams>;
+declare class UsersTosAgreementsResource extends UsersTosAgreementsResource_base {
+    constructor(client: Client);
+}
+export default UsersTosAgreementsResource;

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

@@ -0,0 +1,31 @@
+import { Verification } from '../models';
+import { VerificationRequest } from '../requests';
+import { Client, ResourceCtor } from './base';
+declare const VerificationResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<Verification>;
+        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<Verification>;
+        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<Verification, import("../types").QueryParams>;
+declare class VerificationResource extends VerificationResource_base {
+    constructor(client: Client);
+    create(req: VerificationRequest): Promise<Verification>;
+    update({ code, id, }: {
+        code: string;
+        id: string;
+    }): Promise<Verification>;
+}
+export default VerificationResource;

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

@@ -0,0 +1,48 @@
+import { Saving, WalletTransaction } from '../models';
+import { WalletTransactionQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const WalletTransactionsResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<WalletTransaction>;
+        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?: WalletTransactionQuery): Promise<WalletTransaction>;
+        first(query?: WalletTransactionQuery): Promise<WalletTransaction | null>;
+        count(query?: WalletTransactionQuery): Promise<number>;
+        page(query?: WalletTransactionQuery | undefined, cursor?: string | undefined): Promise<{
+            items: WalletTransaction[];
+            nextCursor: string | null;
+        }>;
+        all(query?: WalletTransactionQuery): AsyncGenerator<WalletTransaction, 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<WalletTransaction>;
+        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<WalletTransaction, WalletTransactionQuery>;
+declare class WalletTransactionsResource extends WalletTransactionsResource_base {
+    constructor(client: Client);
+    create(amount: number, transactionType: string, walletUri: string): Promise<WalletTransaction>;
+    /**
+     * @deprecated Method name has a typo. Retained for API compatibility.
+     * A properly-named alias (`relatedWallet`) will be introduced in v2. See cuenca-js#59.
+     */
+    realtedWallet(walletUri: string): Promise<Saving | null>;
+}
+export default WalletTransactionsResource;

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

@@ -0,0 +1,34 @@
+import { Account, BridgeAccount, WhatsAppTransfer } from '../models';
+import { Client, ResourceCtor } from './base';
+type AccountDestination = Account | BridgeAccount;
+declare const WhatsAppTransferResource_base: {
+    new (...args: any[]): {
+        one(query?: import("../types").QueryParams): Promise<WhatsAppTransfer>;
+        first(query?: import("../types").QueryParams): Promise<WhatsAppTransfer | null>;
+        count(query?: import("../types").QueryParams): Promise<number>;
+        page(query?: import("../types").QueryParams | undefined, cursor?: string | undefined): Promise<{
+            items: WhatsAppTransfer[];
+            nextCursor: string | null;
+        }>;
+        all(query?: import("../types").QueryParams): AsyncGenerator<WhatsAppTransfer, 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<WhatsAppTransfer>;
+        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<WhatsAppTransfer, import("../types").QueryParams>;
+declare class WhatsAppTransferResource extends WhatsAppTransferResource_base {
+    constructor(client: Client);
+    accountDestination(destinationUri: string): Promise<AccountDestination | null>;
+}
+export default WhatsAppTransferResource;