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

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

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

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;

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;