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

package/build/{data-ca00ac2d.cjs → data-added373.cjs}

@@ -499,6 +499,26 @@ const UserStatus = {
 const UserType = {
     Moral: 'moral',
     Physical: 'physical',
+    LegalPerson: 'legal_person',
+};
+const OperatorRole = {
+    Operator: 'operator',
+    Authorizer: 'authorizer',
+};
+const OperatorStatus = {
+    Active: 'active',
+    Disabled: 'disabled',
+};
+const PaymentOrderStatus = {
+    Created: 'created',
+    Authorized: 'authorized',
+    Rejected: 'rejected',
+    Expired: 'expired',
+};
+const PaymentOrderLineStatus = {
+    Pending: 'pending',
+    Invalid: 'invalid',
+    Submitted: 'submitted',
 };
 const VerificationStatus = {
     Created: 'created',
@@ -646,7 +666,11 @@ exports.MLIndicatorLevel = MLIndicatorLevel;
 exports.MLIndicatorPeriod = MLIndicatorPeriod;
 exports.MLIndicatorType = MLIndicatorType;
 exports.Network = Network;
+exports.OperatorRole = OperatorRole;
+exports.OperatorStatus = OperatorStatus;
 exports.PLDFilterType = PLDFilterType;
+exports.PaymentOrderLineStatus = PaymentOrderLineStatus;
+exports.PaymentOrderStatus = PaymentOrderStatus;
 exports.Phase = Phase;
 exports.SATRegimeCode = SATRegimeCode;
 exports.SATRegimeLabels = SATRegimeLabels;

package/build/{data-91da6d58.mjs → data-fa440a47.mjs}

@@ -497,6 +497,26 @@ const UserStatus = {
 const UserType = {
     Moral: 'moral',
     Physical: 'physical',
+    LegalPerson: 'legal_person',
+};
+const OperatorRole = {
+    Operator: 'operator',
+    Authorizer: 'authorizer',
+};
+const OperatorStatus = {
+    Active: 'active',
+    Disabled: 'disabled',
+};
+const PaymentOrderStatus = {
+    Created: 'created',
+    Authorized: 'authorized',
+    Rejected: 'rejected',
+    Expired: 'expired',
+};
+const PaymentOrderLineStatus = {
+    Pending: 'pending',
+    Invalid: 'invalid',
+    Submitted: 'submitted',
 };
 const VerificationStatus = {
     Created: 'created',
@@ -622,4 +642,4 @@ const coerceDatesWithDefaults = (obj, fields) => {
   return result;
 };
 
-export { AlertStatus as A, BridgeAccountStatus as B, CardStatus as C, DepositNetwork as D, EntryType as E, FileFormat as F, SATRegimeCode as G, SATRegimeLabels as H, KYCFileType as K, MLIndicatorLevel as M, Network as N, Phase as P, State as S, TrackDataMethod as T, UserStatus as U, VerificationType as V, WalletTransactionType as W, camelize as a, BridgeBankAccountStatus as b, coerceDatesWithDefaults as c, dateToUTC as d, BridgeTransactionType as e, CardErrorType as f, CardFundingType as g, CardIssuer as h, CardTransactionType as i, CardType as j, CommissionType as k, Currency as l, KYCValidationSource as m, MLIndicatorType as n, MLIndicatorPeriod as o, PLDFilterType as p, Country as q, ServiceProviderCategory as r, snakeize as s, SavingCategory as t, SessionType as u, SourceAlertType as v, TransactionStatus as w, TransferNetwork as x, UserType as y, VerificationStatus as z };
+export { AlertStatus as A, BridgeAccountStatus as B, CardStatus as C, DepositNetwork as D, EntryType as E, FileFormat as F, PaymentOrderStatus as G, PaymentOrderLineStatus as H, VerificationStatus as I, SATRegimeCode as J, KYCFileType as K, SATRegimeLabels as L, MLIndicatorLevel as M, Network as N, OperatorRole as O, Phase as P, State as S, TrackDataMethod as T, UserStatus as U, VerificationType as V, WalletTransactionType as W, camelize as a, BridgeBankAccountStatus as b, coerceDatesWithDefaults as c, dateToUTC as d, BridgeTransactionType as e, CardErrorType as f, CardFundingType as g, CardIssuer as h, CardTransactionType as i, CardType as j, CommissionType as k, Currency as l, KYCValidationSource as m, MLIndicatorType as n, MLIndicatorPeriod as o, PLDFilterType as p, Country as q, ServiceProviderCategory as r, snakeize as s, SavingCategory as t, SessionType as u, SourceAlertType as v, TransactionStatus as w, TransferNetwork as x, UserType as y, OperatorStatus as z };

package/build/dts/index.d.ts

@@ -1,5 +1,5 @@
 import { Client } from './client';
-import { AccountResource, AlertResource, ApiKeyResource, ArpcResource, BalanceEntryResource, BillPaymentResource, BridgeAccountResource, BridgeBankAccountResource, BridgeClabeResource, BridgeTransactionResource, CardActivationResource, CardResource, CardTransactionResource, CardValidationResource, CommissionResource, DepositResource, FileResource, FraudFundsTransferResource, KYCValidationsResource, LoginTokenResource, PartnerResource, PostalCodeResource, ReportResource, SavingResource, ServiceProviderResource, SessionResource, StatementResource, TransferResource, UserCredentialResource, UserLoginResource, UserReportResource, UserResource, UsersTosAgreementsResource, VerificationResource, WalletTransactionsResource, WhatsAppTransferResource } from './resources';
+import { AccountResource, AlertResource, ApiKeyResource, ArpcResource, BalanceEntryResource, BillPaymentResource, BridgeAccountResource, BridgeBankAccountResource, BridgeClabeResource, BridgeTransactionResource, CardActivationResource, CardResource, CardTransactionResource, CardValidationResource, CommissionResource, DepositResource, FileResource, FraudFundsTransferResource, KYCValidationsResource, LegalPersonResource, LoginTokenResource, OperatorLoginResource, OperatorResource, PartnerResource, PaymentOrderResource, PostalCodeResource, ReportResource, SavingResource, ServiceProviderResource, SessionResource, StatementResource, TransferResource, UserCredentialResource, UserLoginResource, UserReportResource, UserResource, UsersTosAgreementsResource, VerificationResource, WalletTransactionsResource, WhatsAppTransferResource } from './resources';
 interface CuencaOptions {
     apiKey?: string;
     apiSecret?: string;
@@ -29,8 +29,12 @@ export declare class Cuenca {
     files: FileResource;
     fraudFundsTransfers: FraudFundsTransferResource;
     kycValidations: KYCValidationsResource;
+    legalPersons: LegalPersonResource;
     loginTokens: LoginTokenResource;
+    operatorLogins: OperatorLoginResource;
+    operators: OperatorResource;
     partners: PartnerResource;
+    paymentOrders: PaymentOrderResource;
     postalCodes: PostalCodeResource;
     reports: ReportResource;
     savings: SavingResource;

package/build/dts/models/index.d.ts

@@ -17,7 +17,12 @@ export { Deposit } from './deposit';
 export { File } from './file';
 export { FraudFundsTransfer } from './fraudFundsTransfer';
 export { KYCValidations } from './kycValidations';
+export { LegalPerson } from './legalPerson';
 export { LoginToken } from './loginToken';
+export { Operator } from './operator';
+export { OperatorLogin } from './operatorLogin';
+export { PaymentOrder } from './paymentOrder';
+export type { PaymentOrderLine } from './paymentOrder';
 export { Partner } from './partner';
 export { PostalCode } from './postalCode';
 export { Saving } from './saving';

package/build/dts/models/legalPerson.d.ts

@@ -0,0 +1,10 @@
+import { WireObject } from '../helpers/case';
+import { LegalRepresentatives } from '../types';
+import { BaseUser } from './baseUser';
+export interface LegalPerson extends BaseUser {
+    legalName?: string;
+    legalRepresentatives?: LegalRepresentatives[];
+}
+export declare const LegalPerson: {
+    fromObject: (obj: WireObject) => LegalPerson;
+};

package/build/dts/models/operator.d.ts

@@ -0,0 +1,17 @@
+import { WireObject } from '../helpers/case';
+import { OperatorRole, OperatorStatus } from '../types';
+export interface Operator {
+    id?: string;
+    createdAt?: Date | null;
+    updatedAt?: Date | null;
+    platformId?: string;
+    name?: string;
+    email?: string;
+    phone?: string;
+    companyUserId?: string;
+    role?: OperatorRole;
+    status?: OperatorStatus;
+}
+export declare const Operator: {
+    fromObject: (obj: WireObject) => Operator;
+};

package/build/dts/models/operatorLogin.d.ts

@@ -0,0 +1,11 @@
+import { WireObject } from '../helpers/case';
+import { OperatorRole } from '../types';
+export interface OperatorLogin {
+    sessionToken?: string;
+    operatorId?: string;
+    role?: OperatorRole;
+    companyUserId?: string;
+}
+export declare const OperatorLogin: {
+    fromObject: (obj: WireObject) => OperatorLogin;
+};

package/build/dts/models/paymentOrder.d.ts

@@ -0,0 +1,42 @@
+import { WireObject } from '../helpers/case';
+import { PaymentOrderLineStatus, PaymentOrderStatus } from '../types';
+export interface PaymentOrderLine {
+    index?: number;
+    accountNumber?: string;
+    recipientName?: string;
+    amount?: number;
+    descriptor?: string;
+    status?: PaymentOrderLineStatus;
+    error?: string;
+    transferId?: string;
+}
+export interface PaymentOrder {
+    id?: string;
+    createdAt?: Date | null;
+    updatedAt?: Date | null;
+    expiresAt?: Date | null;
+    accountNumber?: string;
+    recipientName?: string;
+    amount?: number;
+    descriptor?: string;
+    idempotencyKey?: string;
+    userId?: string;
+    platformId?: string;
+    status?: PaymentOrderStatus;
+    createdByActorId?: string;
+    authorizedByActorId?: string;
+    authorizedAt?: Date | null;
+    rejectedByActorId?: string;
+    rejectedAt?: Date | null;
+    rejectionReason?: string;
+    transferId?: string;
+    isBatch?: boolean;
+    lines?: PaymentOrderLine[];
+    linesTotal?: number;
+    linesValid?: number;
+    linesInvalid?: number;
+    linesSubmitted?: number;
+}
+export declare const PaymentOrder: {
+    fromObject: (obj: WireObject) => PaymentOrder;
+};

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

@@ -8,6 +8,12 @@ export { CardValidationRequest } from './cardValidationRequest';
 export { FileUploadRequest } from './fileUploadRequest';
 export { FraudFundsTransferRequest } from './fraudFundsTransferRequest';
 export { KYCValidationsRequest } from './kycValidationsRequest';
+export { LegalPersonRequest, LegalPersonUpdateRequest, } from './legalPersonRequest';
+export type { LegalRepresentativeRequest } from './legalPersonRequest';
+export { OperatorRequest, OperatorUpdateRequest } from './operatorRequest';
+export { OperatorLoginRequest } from './operatorLoginRequest';
+export { PaymentOrderRejectRequest, PaymentOrderRequest, } from './paymentOrderRequest';
+export type { PaymentOrderItemRequest } from './paymentOrderRequest';
 export { PartnerUserRequest } from './partnerUserRequest';
 export { ReportGenerateRequest } from './reportGenerateRequest';
 export { SavingRequest } from './savingRequest';

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

@@ -0,0 +1,33 @@
+import { WireObject } from '../helpers/case';
+import { AddressUpdateRequest } from './addressUpdateRequest';
+export interface LegalRepresentativeRequest {
+    names: string;
+    firstSurname: string;
+    job: string;
+    phoneNumber: string;
+    emailAddress: string;
+    secondSurname?: string;
+    curp?: string;
+    rfc?: string;
+    address?: AddressUpdateRequest;
+}
+export interface LegalPersonRequest {
+    legalName: string;
+    rfc: string;
+    address: AddressUpdateRequest;
+    legalRepresentatives: LegalRepresentativeRequest[];
+}
+export declare const LegalPersonRequest: {
+    toObject: (req: LegalPersonRequest) => WireObject;
+    toCleanObject: (req: LegalPersonRequest) => WireObject;
+};
+export interface LegalPersonUpdateRequest {
+    legalName?: string;
+    rfc?: string;
+    address?: AddressUpdateRequest;
+    legalRepresentatives?: LegalRepresentativeRequest[];
+}
+export declare const LegalPersonUpdateRequest: {
+    toObject: (req?: LegalPersonUpdateRequest) => WireObject;
+    toCleanObject: (req?: LegalPersonUpdateRequest) => WireObject;
+};

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

@@ -0,0 +1,9 @@
+import { WireObject } from '../helpers/case';
+export interface OperatorLoginRequest {
+    email: string;
+    password: string;
+}
+export declare const OperatorLoginRequest: {
+    toObject: (req: OperatorLoginRequest) => WireObject;
+    toCleanObject: (req: OperatorLoginRequest) => WireObject;
+};

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

@@ -0,0 +1,24 @@
+import { WireObject } from '../helpers/case';
+import { OperatorRole, OperatorStatus } from '../types';
+export interface OperatorRequest {
+    name: string;
+    email: string;
+    phone: string;
+    companyUserId: string;
+    role: OperatorRole;
+    status?: OperatorStatus;
+}
+export declare const OperatorRequest: {
+    toObject: (req: OperatorRequest) => WireObject;
+    toCleanObject: (req: OperatorRequest) => WireObject;
+};
+export interface OperatorUpdateRequest {
+    name?: string;
+    phone?: string;
+    role?: OperatorRole;
+    status?: OperatorStatus;
+}
+export declare const OperatorUpdateRequest: {
+    toObject: (req?: OperatorUpdateRequest) => WireObject;
+    toCleanObject: (req?: OperatorUpdateRequest) => WireObject;
+};

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

@@ -0,0 +1,28 @@
+import { WireObject } from '../helpers/case';
+export interface PaymentOrderItemRequest {
+    accountNumber: string;
+    recipientName: string;
+    amount: number;
+    descriptor: string;
+}
+/** Unitario XOR batch: pass line fields OR `items`, plus `idempotencyKey`. */
+export interface PaymentOrderRequest {
+    accountNumber?: string;
+    recipientName?: string;
+    amount?: number;
+    descriptor?: string;
+    items?: PaymentOrderItemRequest[];
+    idempotencyKey: string;
+    expiresInHours?: number;
+}
+export declare const PaymentOrderRequest: {
+    toObject: (req: PaymentOrderRequest) => WireObject;
+    toCleanObject: (req: PaymentOrderRequest) => WireObject;
+};
+export interface PaymentOrderRejectRequest {
+    rejectionReason: string;
+}
+export declare const PaymentOrderRejectRequest: {
+    toObject: (req: PaymentOrderRejectRequest) => WireObject;
+    toCleanObject: (req: PaymentOrderRejectRequest) => WireObject;
+};

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

@@ -17,8 +17,12 @@ 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 LegalPersonResource } from './legalPersons';
 export { default as LoginTokenResource } from './loginTokens';
+export { default as OperatorLoginResource } from './operatorLogins';
+export { default as OperatorResource } from './operators';
 export { default as PartnerResource } from './partners';
+export { default as PaymentOrderResource } from './paymentOrders';
 export { default as PostalCodeResource } from './postalCodes';
 export { default as ReportResource } from './reports';
 export { default as SavingResource } from './savings';

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

@@ -0,0 +1,54 @@
+import { LegalPerson } from '../models';
+import { LegalPersonRequest, LegalPersonUpdateRequest } from '../requests';
+import { QueryParams } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const LegalPersonResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<LegalPerson>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        one(query?: QueryParams): Promise<LegalPerson>;
+        first(query?: QueryParams): Promise<LegalPerson | null>;
+        count(query?: QueryParams): Promise<number>;
+        page(query?: QueryParams | undefined, cursor?: string | undefined): Promise<{
+            items: LegalPerson[];
+            nextCursor: string | null;
+        }>;
+        all(query?: QueryParams): AsyncGenerator<LegalPerson, any, unknown>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        retrieve(id: string): Promise<LegalPerson>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & {
+    new (...args: any[]): {
+        _update(id: string, data: import("../helpers/case").WireObject): Promise<LegalPerson>;
+        client: Client;
+        path: string;
+        fromObject: import("./base").ModelFactory<unknown>;
+        toParams(query: QueryParams): import("../helpers/case").WireObject;
+        toQueryString(query: QueryParams): string;
+    };
+} & ResourceCtor<LegalPerson, QueryParams>;
+declare class LegalPersonResource extends LegalPersonResource_base {
+    constructor(client: Client);
+    create(req: LegalPersonRequest): Promise<LegalPerson>;
+    update(legalPersonId: string, req: LegalPersonUpdateRequest): Promise<LegalPerson>;
+}
+export default LegalPersonResource;

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

@@ -0,0 +1,19 @@
+import { OperatorLogin } from '../models';
+import { Client, ResourceCtor } from './base';
+declare const OperatorLoginResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<OperatorLogin>;
+        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<OperatorLogin, import("../types").QueryParams>;
+declare class OperatorLoginResource extends OperatorLoginResource_base {
+    private sessionIdInHeaders;
+    constructor(client: Client);
+    create(email: string, password: string): Promise<OperatorLogin>;
+    clearSessionHeader(): void;
+}
+export default OperatorLoginResource;

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/paymentOrders.d.ts

@@ -0,0 +1,57 @@
+import { PaymentOrder } from '../models';
+import { PaymentOrderRequest } from '../requests';
+import { PaymentOrderQuery } from '../types';
+import { Client, ResourceCtor } from './base';
+declare const PaymentOrderResource_base: {
+    new (...args: any[]): {
+        _create(data: import("../helpers/case").WireObject): Promise<PaymentOrder>;
+        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?: PaymentOrderQuery): Promise<PaymentOrder>;
+        first(query?: PaymentOrderQuery): Promise<PaymentOrder | null>;
+        count(query?: PaymentOrderQuery): Promise<number>;
+        page(query?: PaymentOrderQuery | undefined, cursor?: string | undefined): Promise<{
+            items: PaymentOrder[];
+            nextCursor: string | null;
+        }>;
+        all(query?: PaymentOrderQuery): AsyncGenerator<PaymentOrder, 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<PaymentOrder>;
+        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<PaymentOrder, PaymentOrderQuery>;
+declare class PaymentOrderResource extends PaymentOrderResource_base {
+    constructor(client: Client);
+    create(req: PaymentOrderRequest, { operatorId }: {
+        operatorId: string;
+    }): Promise<PaymentOrder>;
+    validate(req: PaymentOrderRequest, { operatorId }: {
+        operatorId: string;
+    }): Promise<PaymentOrder>;
+    authorize(paymentOrderId: string, { operatorId, otp }: {
+        operatorId: string;
+        otp: string;
+    }): Promise<PaymentOrder>;
+    reject(paymentOrderId: string, { operatorId, rejectionReason, }: {
+        operatorId: string;
+        rejectionReason: string;
+    }): Promise<PaymentOrder>;
+}
+export default PaymentOrderResource;

package/build/dts/types/enums.d.ts

@@ -528,8 +528,32 @@ export type UserStatus = typeof UserStatus[keyof typeof UserStatus];
 export declare const UserType: {
     readonly Moral: "moral";
     readonly Physical: "physical";
+    readonly LegalPerson: "legal_person";
 };
 export type UserType = typeof UserType[keyof typeof UserType];
+export declare const OperatorRole: {
+    readonly Operator: "operator";
+    readonly Authorizer: "authorizer";
+};
+export type OperatorRole = typeof OperatorRole[keyof typeof OperatorRole];
+export declare const OperatorStatus: {
+    readonly Active: "active";
+    readonly Disabled: "disabled";
+};
+export type OperatorStatus = typeof OperatorStatus[keyof typeof OperatorStatus];
+export declare const PaymentOrderStatus: {
+    readonly Created: "created";
+    readonly Authorized: "authorized";
+    readonly Rejected: "rejected";
+    readonly Expired: "expired";
+};
+export type PaymentOrderStatus = typeof PaymentOrderStatus[keyof typeof PaymentOrderStatus];
+export declare const PaymentOrderLineStatus: {
+    readonly Pending: "pending";
+    readonly Invalid: "invalid";
+    readonly Submitted: "submitted";
+};
+export type PaymentOrderLineStatus = typeof PaymentOrderLineStatus[keyof typeof PaymentOrderLineStatus];
 export declare const VerificationStatus: {
     readonly Created: "created";
     readonly NotVerified: "not_verified";

package/build/dts/types/queries/index.d.ts

@@ -10,7 +10,9 @@ export type { BridgeTransactionQuery } from './bridgeTransactionQuery';
 export type { CardsQuery } from './cardsQuery';
 export type { CardTransactionQuery } from './cardTransactionQuery';
 export type { DepositQuery } from './depositQuery';
+export type { OperatorQuery } from './operatorQuery';
 export type { PartnerQuery } from './partnerQuery';
+export type { PaymentOrderQuery } from './paymentOrderQuery';
 export type { PostalCodeQuery } from './postalCodeQuery';
 export type { QueryParams } from './queryParams';
 export type { StatementQuery } from './statementQuery';

package/build/dts/types/queries/operatorQuery.d.ts

@@ -0,0 +1,4 @@
+import { QueryParams } from './queryParams';
+export interface OperatorQuery extends QueryParams {
+    email?: string;
+}

package/build/dts/types/queries/paymentOrderQuery.d.ts

@@ -0,0 +1,8 @@
+import { PaymentOrderStatus } from '../enums';
+import { QueryParams } from './queryParams';
+export interface PaymentOrderQuery extends QueryParams {
+    status?: PaymentOrderStatus;
+    accountNumber?: string;
+    idempotencyKey?: string;
+    isBatch?: boolean;
+}