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

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,36 @@
+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 LoginTokenResource } from './loginTokens';
+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/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/partners.d.ts

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

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

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

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

@@ -0,0 +1,8 @@
+import { Client, Resource } from './base';
+declare class ReportResource extends Resource<unknown> {
+    constructor(client: Client);
+    generateXml({ committeeMeetingDate, }: {
+        committeeMeetingDate: string;
+    }): Promise<unknown>;
+}
+export default ReportResource;

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

@@ -0,0 +1,62 @@
+import { Saving } from '../models';
+import { Client, ResourceCtor } from './base';
+declare const SavingResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<Saving>;
+        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<Saving>;
+        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<Saving>;
+        first(query?: import("../types").QueryParams): Promise<Saving | null>;
+        count(query?: import("../types").QueryParams): Promise<number>;
+        page(query?: import("../types").QueryParams | undefined, cursor?: string | undefined): Promise<{
+            items: Saving[];
+            nextCursor: string | null;
+        }>;
+        all(query?: import("../types").QueryParams): AsyncGenerator<Saving, 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<Saving>;
+        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<Saving>;
+        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<Saving, import("../types").QueryParams>;
+declare class SavingResource extends SavingResource_base {
+    constructor(client: Client);
+    create(category: string, goalAmount: number, goalDate: string, name: string): Promise<Saving>;
+    deactivate(savingId: string): Promise<Saving>;
+    update(savingId: string, category: string, goalAmount: number, goalDate: string, name: string): Promise<Saving>;
+}
+export default SavingResource;

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

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

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

@@ -0,0 +1,43 @@
+import { Session } from '../models';
+import { Client, ResourceCtor } from './base';
+declare const SessionResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<Session>;
+        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<Session>;
+        first(query?: import("../types").QueryParams): Promise<Session | null>;
+        count(query?: import("../types").QueryParams): Promise<number>;
+        page(query?: import("../types").QueryParams | undefined, cursor?: string | undefined): Promise<{
+            items: Session[];
+            nextCursor: string | null;
+        }>;
+        all(query?: import("../types").QueryParams): AsyncGenerator<Session, 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<Session>;
+        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<Session, import("../types").QueryParams>;
+declare class SessionResource extends SessionResource_base {
+    private readonly isBridge;
+    constructor(client: Client, isBridge?: boolean);
+    create(userId: string, type: string, successUrl?: string, failureUrl?: string): Promise<Session>;
+}
+export default SessionResource;

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

@@ -0,0 +1,44 @@
+import { Statement } from '../models';
+import { StatementQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const StatementResource_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[]): {
+        one(query?: StatementQuery): Promise<Statement>;
+        first(query?: StatementQuery): Promise<Statement | null>;
+        count(query?: StatementQuery): Promise<number>;
+        page(query?: StatementQuery | undefined, cursor?: string | undefined): Promise<{
+            items: Statement[];
+            nextCursor: string | null;
+        }>;
+        all(query?: StatementQuery): AsyncGenerator<Statement, 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<Statement, StatementQuery>;
+declare class StatementResource extends StatementResource_base {
+    constructor(client: Client);
+    pdf(id: string): Promise<unknown>;
+    xml(id: string): Promise<unknown>;
+    downloadFiles({ userId, year, month, }: {
+        userId: string;
+        year: number;
+        month: number;
+    }): Promise<{
+        statement: Statement;
+        pdf: unknown;
+        xml: unknown;
+    }>;
+}
+export default StatementResource;