wapi-client 0.18.0-beta.3 → 0.18.0-beta.5

package/dist/client.cjs

@@ -1,2341 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// src/client.ts
-var client_exports = {};
-__export(client_exports, {
-  Client: () => Client,
-  createClientWithHttp: () => createClientWithHttp,
-  createClientWithWS: () => createClientWithWS
-});
-module.exports = __toCommonJS(client_exports);
-var import_api = require("./api/index.cjs");
-var import_errors = require("./lib/errors.cjs");
-var import_env = require("./lib/env.cjs");
-var import_aggregate_transfers = require("./fns/aggregate-transfers/aggregate-transfers.cjs");
-var import_create_access_token = require("./fns/create-access-token/create-access-token.cjs");
-var import_create_apikey = require("./fns/create-apikey/create-apikey.cjs");
-var import_create_contract = require("./fns/create-contract/create-contract.cjs");
-var import_create_deposit = require("./fns/create-deposit/create-deposit.cjs");
-var import_create_exchange = require("./fns/create-exchange/create-exchange.cjs");
-var import_create_index = require("./fns/create-index/create-index.cjs");
-var import_create_token = require("./fns/create-token/create-token.cjs");
-var import_create_transfer = require("./fns/create-transfer/create-transfer.cjs");
-var import_create_transfer_group = require("./fns/create-transfer-group/create-transfer-group.cjs");
-var import_create_transfers = require("./fns/create-transfers/create-transfers.cjs");
-var import_create_wallet = require("./fns/create-wallet/create-wallet.cjs");
-var import_create_withdrawal = require("./fns/create-withdrawal/create-withdrawal.cjs");
-var import_export_balance_history = require("./fns/export-balance-history/export-balance-history.cjs");
-var import_drop_index = require("./fns/drop-index/drop-index.cjs");
-var import_export_balances = require("./fns/export-balances/export-balances.cjs");
-var import_export_tokens = require("./fns/export-tokens/export-tokens.cjs");
-var import_export_transfer_groups = require("./fns/export-transfer-groups/export-transfer-groups.cjs");
-var import_export_transfers = require("./fns/export-transfers/export-transfers.cjs");
-var import_export_wallets = require("./fns/export-wallets/export-wallets.cjs");
-var import_find_apikeys = require("./fns/find-apikeys/find-apikeys.cjs");
-var import_find_balances = require("./fns/find-balances/find-balances.cjs");
-var import_find_indexes = require("./fns/find-indexes/find-indexes.cjs");
-var import_find_tokens = require("./fns/find-tokens/find-tokens.cjs");
-var import_find_transfer_groups = require("./fns/find-transfer-groups/find-transfer-groups.cjs");
-var import_find_transfers = require("./fns/find-transfers/find-transfers.cjs");
-var import_find_wallets = require("./fns/find-wallets/find-wallets.cjs");
-var import_get_balance = require("./fns/get-balance/get-balance.cjs");
-var import_get_balance_history = require("./fns/get-balance-history/get-balance-history.cjs");
-var import_get_export = require("./fns/get-export/get-export.cjs");
-var import_get_flags = require("./fns/get-flags/get-flags.cjs");
-var import_get_statistics = require("./fns/get-statistics/get-statistics.cjs");
-var import_get_token = require("./fns/get-token/get-token.cjs");
-var import_get_transfer = require("./fns/get-transfer/get-transfer.cjs");
-var import_get_transfer_group = require("./fns/get-transfer-group/get-transfer-group.cjs");
-var import_get_wallet = require("./fns/get-wallet/get-wallet.cjs");
-var import_healthcheck = require("./fns/healthcheck/healthcheck.cjs");
-var import_list_exports = require("./fns/list-exports/list-exports.cjs");
-var import_reverse_transfer = require("./fns/reverse-transfer/reverse-transfer.cjs");
-var import_reverse_transfer_group = require("./fns/reverse-transfer-group/reverse-transfer-group.cjs");
-var import_reverse_transfers = require("./fns/reverse-transfers/reverse-transfers.cjs");
-var import_set_flags = require("./fns/set-flags/set-flags.cjs");
-var import_update_token = require("./fns/update-token/update-token.cjs");
-var import_update_apikey = require("./fns/update-apikey/update-apikey.cjs");
-var import_update_transfer = require("./fns/update-transfer/update-transfer.cjs");
-var import_update_transfer_group = require("./fns/update-transfer-group/update-transfer-group.cjs");
-var import_update_transfer_groups = require("./fns/update-transfer-groups/update-transfer-groups.cjs");
-var import_update_transfers = require("./fns/update-transfers/update-transfers.cjs");
-var import_update_wallet = require("./fns/update-wallet/update-wallet.cjs");
-var Client = class {
-  /**
-   * @internal
-   */
-  constructor(_apiClient, initialConf) {
-    /**
-     * The BaseClient in use for communication with WAPI Server, manages the actual networking
-     */
-    __publicField(this, "api");
-    /**
-     * Promise resolving to ID upon connection opening
-     */
-    __publicField(this, "$connect");
-    __publicField(this, "config", {});
-    this.api = _apiClient;
-    this.$connect = _apiClient.$connect;
-    if (initialConf) {
-      this.configure(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, initialConf.token && { token: initialConf.token }), initialConf.sendingTimeout && {
-        sendingTimeout: initialConf.sendingTimeout
-      }), initialConf.connectingTimeout && {
-        connectingTimeout: initialConf.connectingTimeout
-      }), initialConf.reconnectingTimeout && {
-        reconnectingTimeout: initialConf.reconnectingTimeout
-      }), initialConf.hooks && { hooks: initialConf.hooks }), initialConf.connectionName && {
-        connectionName: initialConf.connectionName
-      }), initialConf.httpSkipInitialAuthConnection && {
-        httpSkipInitialAuthConnection: initialConf.httpSkipInitialAuthConnection
-      }), initialConf.requestTimeout && {
-        requestTimeout: initialConf.requestTimeout
-      }));
-    }
-  }
-  /**
-   * Close connection to WAPI instance
-   *
-   * ```javascript
-   *
-   * await wapiClient.close();
-   *
-   * ```
-   */
-  close() {
-    return __async(this, null, function* () {
-      return this.api.close();
-    });
-  }
-  /**
-   * Returns WAPI client verion
-   *
-   * ```javascript
-   *
-   * wapiClient.version();
-   *
-   * ```
-   */
-  version() {
-    return import_env.CLIENT_VERSION;
-  }
-  /**
-   * Set a hook function
-   *
-   * ```javascript
-   *
-   * wapiClient.setHook('disconnect', () => {
-   *   console.log('disconnected');
-   * });
-   *
-   * ```
-   * @param {ClientHooks} hookName
-   * @param value
-   */
-  setHook(hookName, value) {
-    if (typeof value !== "function") {
-      throw new TypeError("Hooks can only be functions");
-    }
-    this.api.hooks[hookName] = value;
-    return this;
-  }
-  /**
-   * Overwrite client configuration (default token, default timeout, hooks)
-   *
-   *
-   * ```javascript
-   *
-   * wapiClient.configure({
-   *  token: 'EURO',
-   *  connectingTimeout: 45000,
-   *  reconnectingTimeout: 45000,
-   *  sendingTimeout: 10000,
-   *  requestTimeout: 120000,
-   *  hooks: {
-   *    disconnect: () => {}
-   *  },
-   * });
-   *
-   * ```
-   * @param {ClientConfig} newConf
-   */
-  configure(newConf) {
-    if (newConf.token && typeof newConf.token !== "string" && typeof newConf.token !== "number") {
-      throw new import_errors.ConfigError("CONFIG_INVALID", {
-        field: "token",
-        error: `Must be a string|number, '${newConf.token}' provided`
-      });
-    }
-    [
-      "sendingTimeout",
-      "connectingTimeout",
-      "reconnectingTimeout",
-      "requestTimeout"
-    ].forEach((t) => {
-      if (newConf[t] && typeof newConf[t] !== "number") {
-        throw new import_errors.ConfigError("CONFIG_INVALID", {
-          field: t,
-          error: `Must be a number, '${newConf[t]}' provided`
-        });
-      }
-    });
-    const hooks = newConf.hooks;
-    delete newConf.hooks;
-    this.config = __spreadValues(__spreadValues({}, this.config), newConf);
-    if ("sendingTimeout" in this.config) {
-      this.api.sendingTimeout = this.config.sendingTimeout;
-    }
-    if ("requestTimeout" in this.config) {
-      this.api.requestTimeout = this.config.requestTimeout;
-    }
-    if (hooks) {
-      for (const [hookName, value] of Object.entries(hooks)) {
-        this.setHook(hookName, value);
-      }
-    }
-    return this;
-  }
-  getConfig(key) {
-    return this.config[key];
-  }
-  // CLIENTFNDEFS
-  /*
-   * THIS IS AUTOGENERATED, DO NOT EDIT MANUALLY
-   * if you need custom code add it outside this block
-   */
-  /**
-   *
-   *  Aggregate Transfers using either a simple filter or queryBuilder
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .aggregateTransfers()
-   *   .where({
-   *     type: 'deposit',
-   *     from_wallet: 'EUR',
-   *     to_wallet: 'house',
-   *   })
-   *   .whereMetadata('example', 'test')
-   *   .sum('to.amount as amount')
-   *   .count()
-   *   .groupBy('metadata.even as type', 'hour')
-   *   .options({
-   *     tracking_id: 'hello',
-   *     return_all_intervals: {
-   *       start_time: '2021-07-31 11:00:00',
-   *       end_time: '2021-07-31 13:00:00',
-   *     },
-   *   });
-   *
-   * expect(result).toEqual({
-   *   rows: [
-   *     {
-   *       amount: 25,
-   *       count: 5,
-   *       type: 'even',
-   *       hour: '2021-07-31 12',
-   *     },
-   *     {
-   *       amount: 30,
-   *       count: 5,
-   *       type: 'odd',
-   *       hour: '2021-07-31 12',
-   *     },
-   *     {
-   *       amount: null,
-   *       count: 0,
-   *       type: null,
-   *       hour: '2021-07-31 11',
-   *     },
-   *     {
-   *       amount: null,
-   *       count: 0,
-   *       type: null,
-   *       hour: '2021-07-31 13',
-   *     },
-   *   ],
-   *   metadata: {
-   *     aggregators: [
-   *       {
-   *         function: 'sum',
-   *         field: 'to.amount',
-   *         alias: 'amount',
-   *       },
-   *       {
-   *         function: 'count',
-   *         alias: 'count',
-   *       },
-   *     ],
-   *     groups: [
-   *       {
-   *         type: 'metadata_field',
-   *         field: 'even',
-   *         alias: 'type',
-   *       },
-   *       {
-   *         alias: 'hour',
-   *         field: 'hour',
-   *         type: 'period',
-   *       },
-   *     ],
-   *   },
-   * });
-   *
-   * ```
-   *
-   */
-  aggregateTransfers(input, options) {
-    return (0, import_aggregate_transfers.aggregateTransfers)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Create a JWT token for use with HTTP api
-   *
-   *
-   * ```javascript
-   *
-   * const response = await wapiClient.createAccessToken({
-   *   token: {
-   *     type: 'limited',
-   *     scopes: ['getBalance'],
-   *     filters: {
-   *       wallet_foreign: 'user-1-wallet',
-   *       token_foreign: 'EUR',
-   *     },
-   *     expiresIn: 60,
-   *   },
-   * });
-   *
-   * ```
-   *
-   */
-  createAccessToken(input, options) {
-    return (0, import_create_access_token.createAccessToken)({ client: this }, input != null ? input : {}, options);
-  }
-  /**
-   *
-   *  Create a new API key for accessing WAPI
-   *
-   *
-   * ```javascript
-   *
-   * const response = await wapiClient.createApikey({
-   *   apikey: {
-   *     type: 'admin',
-   *     description: 'My admin API key',
-   *     validUntil: '2025-12-31T23:59:59Z',
-   *     metadata: {
-   *       purpose: 'backend-service',
-   *     },
-   *   },
-   * });
-   *
-   * // Or create a limited API key with specific function access
-   * const limitedResponse = await wapiClient.createApikey({
-   *   apikey: {
-   *     type: 'limited',
-   *     description: 'Read-only API key',
-   *     functions: ['getBalance', 'getWallet', 'findTransfers'],
-   *   },
-   * });
-   *
-   * ```
-   *
-   */
-  createApikey(input, options) {
-    return (0, import_create_apikey.createApikey)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Create a contract like transferGroup
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.createContract({
-   *   foreign: 'MYContract',
-   *   metadata: {
-   *     cool: true,
-   *   },
-   *   value_token: 'EUR',
-   *   value_amount: 100,
-   *   owner: 'oppo',
-   *   buyer: {
-   *     wallet: WALLETS.withEURFunds0.foreign,
-   *     metadata: {
-   *       buying: true,
-   *     },
-   *     amount: 101,
-   *     token: 'EUR',
-   *   },
-   * });
-   *
-   * ```
-   *
-   */
-  createContract(input, options) {
-    return (0, import_create_contract.createContract)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Create a deposit transaction into a wallet, by issuing new tokens to the system.
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.createDeposit(
-   *   {
-   *     identifier: 'mycustomId',
-   *     token: 'ForeignForToken',
-   *     wallet: 'ForeignForWallet',
-   *     amount: 10.01,
-   *     metadata: {
-   *       customJsonBlob: true,
-   *     },
-   *     status: 'finished',
-   *     // transfer_group: TransferGroup.identifier, // existing transfer group identifier
-   *   },
-   *   {
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *     create_wallet_if_not_exists: true,
-   *     return_balance: true,
-   *   },
-   * );
-   *
-   * expect(result).toEqual({
-   *   transfer: expect.objectContaining({
-   *     identifier: 'mycustomId',
-   *     token_foreign: 'ForeignForToken',
-   *     to_wallet_foreign: 'ForeignForWallet',
-   *     amount: 10.01,
-   *     metadata: {
-   *       customJsonBlob: true,
-   *     },
-   *     status: 'finished',
-   *     // ... other fields
-   *   }),
-   *   to_balance: expect.objectContaining({
-   *     token_foreign: 'ForeignForToken',
-   *     wallet_foreign: 'ForeignForWallet',
-   *     pending_amount: 0,
-   *     finished_amount: 10.01,
-   *     amount: 10.01,
-   *     // ... other fields
-   *   }),
-   * });
-   *
-   * ```
-   *
-   */
-  createDeposit(input, options) {
-    return (0, import_create_deposit.createDeposit)({ client: this }, input, options);
-  }
-  /**
-      *
-      *  Create an exchange transfer group - change one token in certain amount for another token of certain amount
-   The transfers are connected and either fail or succeed both
-      * 
-     *
-       * ```javascript
-       *
-     * const result = await wapiClient.createExchange(
-     *   {
-     *     identifier: 'exchange',
-     *     from_identifier: 'exchange1',
-     *     from_wallet: WALLETS.withEURFunds0.foreign,
-     *     from_token: 'EUR',
-     *     from_amount: 10,
-     *     to_identifier: 'exchange2',
-     *     to_token: 'USD',
-     *     to_wallet: WALLETS.withUSDFunds0.foreign,
-     *     to_amount: 20,
-     *     status: 'finished',
-     *     metadata: {
-     *       exchangeRate: 2,
-     *     },
-     *   },
-     *   {
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *   },
-     * );
-     * expect(result).toEqual({
-     *   transfer_group: expect.objectContaining({
-     *     identifier: 'exchange',
-     *     status: 'closed',
-     *     transfer_status: 'finished',
-     *   }),
-     *   transfers: [
-     *     expect.objectContaining({
-     *       status: 'finished',
-     *       amount: 10,
-     *       from_wallet_id: WALLETS.withEURFunds0.id,
-     *       to_wallet_id: WALLETS.withUSDFunds0.id,
-     *       token_id: TOKENS.EUR.id,
-     *       metadata: {
-     *         exchangeRate: 2,
-     *       },
-     *       identifier: 'exchange1',
-     *     }),
-     *     expect.objectContaining({
-     *       status: 'finished',
-     *       amount: 20,
-     *       to_wallet_id: WALLETS.withEURFunds0.id,
-     *       from_wallet_id: WALLETS.withUSDFunds0.id,
-     *       token_id: TOKENS.USD.id,
-     *       metadata: {
-     *         exchangeRate: 2,
-     *       },
-     *       identifier: 'exchange2',
-     *     }),
-     *   ],
-     * });
-     *
-       * ```
-     *
-     */
-  createExchange(input, options) {
-    return (0, import_create_exchange.createExchange)({ client: this }, input, options);
-  }
-  /** Create a metadata index. */
-  createIndex(input, options) {
-    return (0, import_create_index.createIndex)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Create a new Token in the system which can then be transferred between wallets
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.createToken(
-   *   {
-   *     foreign: 'EURO',
-   *     divisor: 10,
-   *     limit: 10,
-   *     public: true,
-   *     metadata: {
-   *       customMetadata: true,
-   *     },
-   *     // belongs_to: 'EURO-wallet'
-   *   },
-   *   {
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   *
-   * expect(result).toEqual({
-   *   token: expect.objectContaining({
-   *     foreign: 'EURO',
-   *     public: true,
-   *     metadata: {
-   *       customMetadata: true,
-   *     },
-   *   }),
-   *   wallet: expect.objectContaining({
-   *     default_allow_positive: false,
-   *     default_allow_negative: true,
-   *     foreign: 'EURO',
-   *     metadata: null,
-   *     type: 'token',
-   *   }),
-   * });
-   *
-   * ```
-   *
-   */
-  createToken(input, options) {
-    return (0, import_create_token.createToken)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Create a transfer of Token amount from one wallet to the other.
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.createTransfer(
-   *   {
-   *     identifier: 'mynewtransferid',
-   *     token: 'EUR',
-   *     from_wallet: WALLETS.withEURFunds0.foreign,
-   *     to_wallet: 'foreignForMbyExistingWallet',
-   *     amount: 10.01,
-   *     metadata: {
-   *       customJSON: true,
-   *     },
-   *     type: 'transfer',
-   *     status: 'pending',
-   *     // transfer_group: TransferGroup.identifier,
-   *   },
-   *   {
-   *     create_to_wallet_if_not_exists: true,
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   *
-   * expect(result).toEqual({
-   *   transfer: expect.objectContaining({
-   *     identifier: 'mynewtransferid',
-   *     token_foreign: 'EUR',
-   *     from_wallet_foreign: WALLETS.withEURFunds0.foreign,
-   *     to_wallet_foreign: 'foreignForMbyExistingWallet',
-   *     amount: 10.01,
-   *     metadata: {
-   *       customJSON: true,
-   *     },
-   *     type: 'transfer',
-   *     status: 'pending',
-   *     // ...
-   *   }),
-   * });
-   *
-   * ```
-   *
-   */
-  createTransfer(input, options) {
-    return (0, import_create_transfer.createTransfer)({ client: this }, input, options);
-  }
-  /**
-      *
-      *  Create a TransferGroup entity to group transfers into a logical or status locked group.
-   Can include the transfers in the same call or if non 'closed' TransferGroup, add the transfers later.
-   Can also include child TransferGroups to create a hierarchy
-      * 
-     *
-       * ```javascript
-       *
-     * const result = await wapiClient.createTransferGroup(
-     *   {
-     *     identifier: 'mytgIdentifier',
-     *     status: 'closed',
-     *     metadata: {
-     *       customJSON: true,
-     *     },
-     *     transfer_status: 'finished',
-     *     // transfer_group: ParentTransferGroup.identifier,
-     *     children: [
-     *       {
-     *         identifier: 'txIdentifier',
-     *         from_wallet: WALLETS.withEURFunds0.foreign,
-     *         to_wallet: 'newWalletForeign',
-     *         token: 'EUR',
-     *         amount: 10,
-     *         type: 'transfer',
-     *         latest_control_hash:
-     *           WALLETS.withEURFunds0.latest_control_hash,
-     *       },
-     *       {
-     *         identifier: 'childTgTransferId',
-     *         from_wallet: 'newWalletForeign',
-     *         to_wallet: WALLETS.withEURFunds0.foreign,
-     *         token: 'EUR',
-     *         amount: 9,
-     *         type: 'transfer',
-     *         latest_control_hash: null, // not needed because we just transferred money there,
-     *       },
-     *     ],
-     *   },
-     *   {
-     *     validate_final_balance_only: true,
-     *     create_to_wallet_if_not_exists: true,
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *   },
-     * );
-     *
-     * expect(result).toEqual(
-     *   expect.objectContaining({
-     *     transfer_group: expect.objectContaining({
-     *       identifier: 'mytgIdentifier',
-     *       status: 'closed',
-     *       metadata: {
-     *         customJSON: true,
-     *       },
-     *       transfer_status: 'finished',
-     *     }),
-     *     transfers: [
-     *       expect.objectContaining({
-     *         identifier: 'txIdentifier',
-     *         from_wallet_foreign: WALLETS.withEURFunds0.foreign,
-     *         to_wallet_foreign: 'newWalletForeign',
-     *         token_foreign: 'EUR',
-     *         amount: 10,
-     *         type: 'transfer',
-     *       }),
-     *       expect.objectContaining({
-     *         identifier: 'childTgTransferId',
-     *         from_wallet_foreign: 'newWalletForeign',
-     *         to_wallet_foreign: WALLETS.withEURFunds0.foreign,
-     *         token_foreign: 'EUR',
-     *         amount: 9,
-     *         type: 'transfer',
-     *       }),
-     *     ],
-     *   }),
-     * );
-     *
-     *
-       * ```
-     *
-     */
-  createTransferGroup(input, options) {
-    return (0, import_create_transfer_group.createTransferGroup)({ client: this }, input != null ? input : {}, options);
-  }
-  /**
-      *
-      *  Create multiple transfers with one call. Transfers are created in a transaction so it either succeeds or fails as one.
-   Will respect internal balance transfers to avoid latest_control_hash
-      * 
-     *
-       * ```javascript
-       *
-     * const result = await wapiClient.createTransfers(
-     *   {
-     *     transfers: [
-     *       {
-     *         type: 'deposit',
-     *         wallet: WALLETS.validForeign2,
-     *         token: 'EURO',
-     *         amount: 10.01,
-     *       },
-     *       {
-     *         from_wallet: WALLETS.validForeign2,
-     *         to_wallet: 'newWalletForeignMby',
-     *         token: 'EURO',
-     *         amount: 10.01,
-     *         latest_control_hash: null, // not required as we just transferred funds
-     *       },
-     *       {
-     *         type: 'withdrawal',
-     *         wallet: 'newWalletForeignMby',
-     *         token: 'EURO',
-     *         amount: 10.01,
-     *         latest_control_hash: null, // not required as we just transferred funds
-     *       },
-     *     ],
-     *   },
-     *   {
-     *     create_to_wallet_if_not_exists: true,
-     *     return_from_balance: true,
-     *     return_to_balance: true,
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *   },
-     * );
-     *
-     * expect(result).toEqual(
-     *   expect.objectContaining({
-     *     transfers: [
-     *       expect.objectContaining({
-     *         type: 'deposit',
-     *         token_foreign: 'EURO',
-     *         to_wallet_foreign: WALLETS.validForeign2,
-     *         amount: 10.01,
-     *       }),
-     *       expect.objectContaining({
-     *         type: 'transfer',
-     *         token_foreign: 'EURO',
-     *         from_wallet_foreign: WALLETS.validForeign2,
-     *         to_wallet_foreign: 'newWalletForeignMby',
-     *         amount: 10.01,
-     *       }),
-     *       expect.objectContaining({
-     *         type: 'withdrawal',
-     *         token_foreign: 'EURO',
-     *         from_wallet_foreign: 'newWalletForeignMby',
-     *         amount: 10.01,
-     *       }),
-     *     ],
-     *     // We are doing a 0 sum with 3 transactions so everything is back to 0
-     *     from_balances: [
-     *       expect.objectContaining({
-     *         token_foreign: 'EURO',
-     *         wallet_foreign: 'EURO',
-     *         amount: 0,
-     *       }),
-     *       expect.objectContaining({
-     *         token_foreign: 'EURO',
-     *         wallet_foreign: WALLETS.validForeign2,
-     *         amount: 0,
-     *       }),
-     *       expect.objectContaining({
-     *         token_foreign: 'EURO',
-     *         wallet_foreign: 'newWalletForeignMby',
-     *         amount: 0,
-     *       }),
-     *     ],
-     *     to_balances: [
-     *       expect.objectContaining({
-     *         token_foreign: 'EURO',
-     *         wallet_foreign: WALLETS.validForeign2,
-     *         amount: 0,
-     *       }),
-     *       expect.objectContaining({
-     *         token_foreign: 'EURO',
-     *         wallet_foreign: 'newWalletForeignMby',
-     *         amount: 0,
-     *       }),
-     *       expect.objectContaining({
-     *         token_foreign: 'EURO',
-     *         wallet_foreign: 'EURO',
-     *         amount: 0,
-     *       }),
-     *     ],
-     *   }),
-     * );
-     *
-     *
-       * ```
-     *
-     */
-  createTransfers(input, options) {
-    return (0, import_create_transfers.createTransfers)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Create a Wallet entity which can then transfer amounts of Tokens.
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.createWallet(
-   *   {
-   *     foreign: 'test-wallet-2',
-   *     name: 'Irrelevant',
-   *     metadata: {
-   *       awesome: true,
-   *       invalid: false,
-   *     },
-   *   },
-   *   {
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   *
-   * expect(result).toEqual({
-   *   wallet: expect.objectContaining({
-   *     foreign: 'test-wallet-2',
-   *     name: 'Irrelevant',
-   *     metadata: {
-   *       awesome: true,
-   *       invalid: false,
-   *     },
-   *   }),
-   * });
-   *
-   *
-   * ```
-   *
-   */
-  createWallet(input, options) {
-    return (0, import_create_wallet.createWallet)({ client: this }, input, options);
-  }
-  /**
-      *
-      *  Create a transfer withdrawing funds from a Wallet.
-   Will default to transferring funds to Token default Wallet.
-      * 
-     *
-       * ```javascript
-       *
-     * const result = await wapiClient.createWithdrawal(
-     *   {
-     *     identifier: 'mycustomId',
-     *     token: 'ForeignForToken',
-     *     wallet: 'ForeignForWallet',
-     *     amount: 10.01,
-     *     metadata: {
-     *       customJsonBlob: true,
-     *     },
-     *     status: 'finished',
-     *     latest_control_hash: null,
-     *     // transfer_group: TransferGroup.identifier, // existing transfer group identifier
-     *   },
-     *   {
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *     return_balance: true,
-     *   },
-     * );
-     *
-     * expect(result).toEqual({
-     *   transfer: expect.objectContaining({
-     *     identifier: 'mycustomId',
-     *     token_foreign: 'ForeignForToken',
-     *     from_wallet_foreign: 'ForeignForWallet',
-     *     amount: 10.01,
-     *     metadata: {
-     *       customJsonBlob: true,
-     *     },
-     *     status: 'finished',
-     *     // ... other fields
-     *   }),
-     *   from_balance: expect.objectContaining({
-     *     token_foreign: 'ForeignForToken',
-     *     wallet_foreign: 'ForeignForWallet',
-     *     pending_amount: 0,
-     *     finished_amount: 89.99,
-     *     amount: 89.99,
-     *     // ... other fields
-     *   }),
-     * });
-     *
-       * ```
-     *
-     */
-  createWithdrawal(input, options) {
-    return (0, import_create_withdrawal.createWithdrawal)({ client: this }, input, options);
-  }
-  /** Drop a metadata index. */
-  dropIndex(input, options) {
-    return (0, import_drop_index.dropIndex)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Output balanceHistory query to an Export
-   *
-   *
-   * ```javascript
-   *
-   * // setup
-   * await wapiClient.createDeposit(
-   *   {
-   *     wallet: 'newWallet',
-   *     amount: 10,
-   *     status: 'pending',
-   *     identifier: 'depositUSD',
-   *     token: 'USD',
-   *   },
-   *   {
-   *     create_wallet_if_not_exists: true,
-   *   },
-   * );
-   * await wapiClient.updateTransfer({
-   *   transfer: 'depositUSD',
-   *   status: 'finished',
-   * });
-   *
-   * const result = await wapiClient.exportBalanceHistory(
-   *   {
-   *     wallet: 'newWallet',
-   *     token: 'USD',
-   *   },
-   *   {
-   *     limit: 0,
-   *     select: [
-   *       'transfer_identifier',
-   *       'pending_amount',
-   *       'finished_amount',
-   *       'pending_amount_from',
-   *       'pending_amount_to',
-   *       'amount',
-   *     ],
-   *     offset: 0,
-   *     order: 'desc',
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   *
-   * ```
-   *
-   */
-  exportBalanceHistory(input, options) {
-    return (0, import_export_balance_history.exportBalanceHistory)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for Balances using either a simple filter or queryBuilder and save the results to an Export
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .exportBalances()
-   *   // .whereIn('wallet', ['test-1', 'test-2'])
-   *   .where('wallet', 'like', 'test-%')
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy('available_balance')
-   *   .select('wallet_foreign', 'token_foreign', 'available_balance')
-   *   .options({
-   *     tracking_id: 'hello',
-   *   });
-   *
-   * ```
-   *
-   */
-  exportBalances(input, options) {
-    return (0, import_export_balances.exportBalances)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for Tokens using either a simple filter or queryBuilder and save the results to an Export
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .exportTokens()
-   *   .whereMetadata('meta', '>', 2)
-   *   .where((builder) => {
-   *     builder.where('status', 'active').orWhere('type', 'value');
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy('foreign')
-   *   .select('id', 'foreign', 'metadata', 'balance_available_balance')
-   *   .options({
-   *     tracking_id: 'hello',
-   *     include_balance: true,
-   *   });
-   *
-   * ```
-   *
-   */
-  exportTokens(input, options) {
-    return (0, import_export_tokens.exportTokens)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for TransferGroups using either a simple filter or queryBuilder and save the results to an Export
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .exportTransferGroups()
-   *   .whereMetadata('even', true)
-   *   .where((builder) => {
-   *     builder.where('status', 'closed').orWhere('transfer_status', 'pending');
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy('identifier')
-   *   .select('id', 'identifier', 'metadata', 'reverses_identifier')
-   *   .options({
-   *     tracking_id: 'hello',
-   *     return_transfers_count: true,
-   *   });
-   *
-   * ```
-   *
-   */
-  exportTransferGroups(input, options) {
-    return (0, import_export_transfer_groups.exportTransferGroups)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for Transfers using either a simple filter or queryBuilder and save the results to an Export
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .exportTransfers()
-   *   .where({
-   *     metadata: {
-   *       example: true,
-   *     },
-   *   })
-   *   .where('id', '>', 1)
-   *   .where((builder) => {
-   *     builder.where('status', 'finished').orWhere('type', 'deposit');
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy(['token_id', { column: 'id', order: 'desc' }])
-   *   .select(
-   *     'id',
-   *     'type',
-   *     'from_wallet_foreign',
-   *     'to_wallet_foreign',
-   *     'amount',
-   *   )
-   *   .options({
-   *     tracking_id: 'hello',
-   *   });
-   *
-   * ```
-   *
-   */
-  exportTransfers(input, options) {
-    return (0, import_export_transfers.exportTransfers)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for Wallets using either a simple filter or queryBuilder and save the results to an Export
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .exportWallets()
-   *   .whereMetadata('meta', '>', 2)
-   *   .where((builder) => {
-   *     builder.where('status', 'active').orWhere('type', 'regular');
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy('foreign')
-   *   .select('id', 'foreign', 'metadata', 'balance_available_balance')
-   *   .options({
-   *     tracking_id: 'hello',
-   *     include_balance_for_token: 'EUR',
-   *   });
-   *
-   * ```
-   *
-   */
-  exportWallets(input, options) {
-    return (0, import_export_wallets.exportWallets)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for API keys using either a simple filter or queryBuilder
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .findApikeys()
-   *   .where({
-   *     type: 'admin',
-   *   })
-   *   .orWhere({
-   *     status: 'active',
-   *   })
-   *   .limit(10)
-   *   .offset(0)
-   *   .orderBy('created_at', 'desc')
-   *   .options({
-   *     tracking_id: 'hello',
-   *     return_metadata_total: true,
-   *   });
-   *
-   * // Or with simple filter
-   * const adminKeys = await wapiClient.findApikeys({
-   *   type: 'admin',
-   *   status: 'active',
-   * });
-   *
-   * ```
-   *
-   */
-  findApikeys(input, options) {
-    return (0, import_find_apikeys.findApikeys)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for Balances using either a simple filter or queryBuilder
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .findBalances()
-   *   .where({
-   *     wallet: WALLETS.validId0,
-   *   })
-   *   .orWhere('amount', '>', 100)
-   *   .orWhere({
-   *     wallet: WALLETS.validId1,
-   *     token: 'USD',
-   *   })
-   *   .orWhere((builder) => {
-   *     builder
-   *       .where('updated_at', '<', '2020-01-01')
-   *       .where('amount', '<', -1000000);
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy('wallet_foreign', 'desc')
-   *   .options({
-   *     tracking_id: 'hello',
-   *     return_metadata_total: true,
-   *   });
-   *
-   * ```
-   *
-   */
-  findBalances(input, options) {
-    return (0, import_find_balances.findBalances)({ client: this }, input, options);
-  }
-  /** Search for metadata indexes. */
-  findIndexes(input, options) {
-    return (0, import_find_indexes.findIndexes)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for Tokens using either a simple filter or queryBuilder
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .findTokens()
-   *   .where({
-   *     metadata: {
-   *       even: true,
-   *       example: 'test',
-   *     },
-   *   })
-   *   .orWhere({
-   *     foreign: 'token-example1',
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy(['foreign', { column: 'id', order: 'desc' }])
-   *   .options({
-   *     tracking_id: 'hello',
-   *     return_metadata_total: true,
-   *     include_balance: true,
-   *   });
-   *
-   * ```
-   *
-   */
-  findTokens(input, options) {
-    return (0, import_find_tokens.findTokens)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for TransferGroups using either a simple filter or queryBuilder
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .findTransferGroups()
-   *   .where({
-   *     metadata: {
-   *       even: true,
-   *       example: 'test',
-   *     },
-   *   })
-   *   .orWhere({
-   *     identifier: 'reverser-example',
-   *   })
-   *   .orWhere((builder) => {
-   *     builder
-   *       .where({
-   *         metadata: {
-   *           kak: true,
-   *         },
-   *       })
-   *       .where('created_at', '>', '2020-01-01');
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy('id', 'desc')
-   *   .select('id', 'type', 'identifier')
-   *   .options({
-   *     tracking_id: 'hello',
-   *     return_metadata_total: true,
-   *     return_transfers_count: true,
-   *   });
-   *
-   * ```
-   *
-   */
-  findTransferGroups(input, options) {
-    return (0, import_find_transfer_groups.findTransferGroups)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for Transfers using either a simple filter or queryBuilder
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .findTransfers()
-   *   .where({
-   *     metadata: {
-   *       example: true,
-   *     },
-   *   })
-   *   .where('id', '>', 1)
-   *   .where((builder) => {
-   *     builder.where('status', 'finished').orWhere('type', 'deposit');
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy(['token_id', { column: 'id', order: 'desc' }])
-   *   .select('id', 'type', 'from_wallet_foreign', 'to_wallet_foreign')
-   *   .options({
-   *     tracking_id: 'hello',
-   *   });
-   *
-   * ```
-   *
-   */
-  findTransfers(input, options) {
-    return (0, import_find_transfers.findTransfers)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Search for Wallets using either a simple filter or queryBuilder
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .findWallets()
-   *   .where({
-   *     metadata: {
-   *       general: true,
-   *     },
-   *   })
-   *   .where('id', '>', 1)
-   *   .where((builder) => {
-   *     builder.whereMetadata('tost', 10).orWhereMetadata('test', 1);
-   *   })
-   *   .limit(5)
-   *   .offset(0)
-   *   .orderBy(['status', { column: 'id', order: 'desc' }])
-   *   .select('id')
-   *   .options({
-   *     tracking_id: 'hello',
-   *   });
-   *
-   * ```
-   *
-   */
-  findWallets(input, options) {
-    return (0, import_find_wallets.findWallets)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Get a specific token/wallet balance
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.getBalance(
-   *   {
-   *     wallet: 'myMbyExistingWallet',
-   *     token: 'MBYTOKEN',
-   *     datetime: '2020-01-01',
-   *   },
-   *   {
-   *     create_wallet_if_not_exists: true,
-   *     create_token_if_not_exists: true,
-   *     create_if_not_exists: true,
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   *
-   * expect(result).toEqual({
-   *   balance: expect.objectContaining({
-   *     wallet_foreign: 'myMbyExistingWallet',
-   *     token_foreign: 'MBYTOKEN',
-   *     pending_amount: 0,
-   *     finished_amount: 0,
-   *     amount: 0,
-   *     latest_control_hash: null,
-   *     available_balance: 0,
-   *     // ...
-   *   }),
-   * });
-   *
-   *
-   * ```
-   *
-   */
-  getBalance(input, options) {
-    return (0, import_get_balance.getBalance)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Get a list of changes to token/wallet balance
-   *
-   *
-   * ```javascript
-   *
-   * // setup
-   * const deposit = await wapiClient.createDeposit(
-   *   {
-   *     wallet: 'newWallet',
-   *     amount: 10,
-   *     status: 'pending',
-   *     identifier: 'depositUSD',
-   *     token: 'USD',
-   *   },
-   *   {
-   *     create_wallet_if_not_exists: true,
-   *   },
-   * );
-   * const updatedTransfer = await wapiClient.updateTransfer({
-   *   transfer: 'depositUSD',
-   *   status: 'finished',
-   * });
-   *
-   * const result = await wapiClient.getBalanceHistory(
-   *   {
-   *     wallet: 'newWallet',
-   *     token: 'USD',
-   *   },
-   *   {
-   *     create_token_if_not_exists: true,
-   *     create_wallet_if_not_exists: true,
-   *     limit: 5,
-   *     select: [
-   *       'transfer_identifier',
-   *       'pending_amount',
-   *       'finished_amount',
-   *       'pending_amount_from',
-   *       'pending_amount_to',
-   *       'amount',
-   *       // 'balance_id',
-   *       // 'transfer_id',
-   *       // 'transfer_control_hash',
-   *       // 'transfer_from_wallet_id',
-   *       // 'transfer_from_wallet_foreign',
-   *       // 'transfer_to_wallet_id',
-   *       // 'transfer_to_wallet_foreign',
-   *       // 'transfer_amount',
-   *       // 'transfer_type',
-   *       // 'transfer_status',
-   *       // 'transfer_force',
-   *       // 'transfer_created_at',
-   *       // 'transfer_updated_at',
-   *       // 'transfer_metadata',
-   *       // 'transfer_transfer_group_id',
-   *       // 'transfer_transfer_group_identifier',
-   *       // 'transfer_reverses_id',
-   *       // 'transfer_reverses_identifier',
-   *       // 'transfer_status_finalized_at',
-   *       // 'token_id',
-   *       // 'token_foreign',
-   *       // 'wallet_id',
-   *       // 'wallet_foreign',
-   *       // 'latest_control_hash',
-   *       // 'updated_at',
-   *     ],
-   *     offset: 0,
-   *     order: 'desc',
-   *     return_metadata_total: true,
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   balances: [
-   *     {
-   *       transfer_identifier: 'depositUSD',
-   *       pending_amount: 0,
-   *       finished_amount: 10,
-   *       pending_amount_to: 0,
-   *       pending_amount_from: 0,
-   *       amount: 10,
-   *     },
-   *     {
-   *       transfer_identifier: 'depositUSD',
-   *       pending_amount: 10,
-   *       finished_amount: 0,
-   *       pending_amount_to: 10,
-   *       pending_amount_from: 0,
-   *       amount: 10,
-   *     },
-   *   ],
-   *   metadata: {
-   *     limit: 5,
-   *     offset: 0,
-   *     total: 2,
-   *     more_rows: false,
-   *   },
-   * });
-   *
-   * ```
-   *
-   */
-  getBalanceHistory(input, options) {
-    return (0, import_get_balance_history.getBalanceHistory)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Get an Export file description
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.getExport(
-   *   {
-   *     identifier: exportingResult.export!.identifier,
-   *   },
-   *   {
-   *     return_signed_url: true,
-   *     tracking_id: 'myLogId',
-   *   },
-   * );
-   *
-   * ```
-   *
-   */
-  getExport(input, options) {
-    return (0, import_get_export.getExport)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Retrieve the current state of configurable Flags for your WAPI instance
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.getFlags();
-   * expect(result.flags).toEqual({
-   *   production: true,
-   *   allow_timestamps: false,
-   * });
-   *
-   * ```
-   *
-   */
-  getFlags(input, options) {
-    return (0, import_get_flags.getFlags)({ client: this }, input != null ? input : {}, options);
-  }
-  /**
-   *
-   *  Get aggregated statistics about WAPI entities
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.getStatistics(
-   *   {
-   *     model: 'Transfer',
-   *     aggregator: 'count',
-   *     group: 'month',
-   *     timezone: 'Europe/Tallinn',
-   *     filter: {
-   *       end_time: new Date(
-   *         `${new Date().getFullYear() + 1}-01-01`,
-   *       ).toISOString(),
-   *       start_time: new Date(
-   *         `${new Date().getFullYear()}-01-01`,
-   *       ).toISOString(),
-   *     },
-   *   },
-   *   {
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   *
-   * expect(result).toEqual({
-   *   rows: [
-   *     {
-   *       aggregate: 4,
-   *       period: `${new Date().getFullYear()}-${(new Date().getMonth() + 1 + '').padStart(2, '0')}`,
-   *     },
-   *   ],
-   * });
-   *
-   * ```
-   *
-   */
-  getStatistics(input, options) {
-    return (0, import_get_statistics.getStatistics)({ client: this }, input != null ? input : {}, options);
-  }
-  /**
-   *
-   *  Get information about token
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.getToken(
-   *   {
-   *     token: 'EURO',
-   *   },
-   *   {
-   *     create_if_not_exists: true,
-   *     // return_only_id: true, // for example purposes we want more than id
-   *     ignore_cache: true,
-   *     include_balance: true,
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   *
-   * expect(result).toEqual({
-   *   token: expect.objectContaining({
-   *     foreign: 'EURO',
-   *     metadata: null,
-   *     balance_amount: null,
-   *     balance_finished_amount: null,
-   *     balance_updated_at: null,
-   *   }),
-   * });
-   *
-   * ```
-   *
-   */
-  getToken(input, options) {
-    return (0, import_get_token.getToken)({ client: this }, input != null ? input : {}, options);
-  }
-  /**
-   *
-   *  Get information about a specific Transfer
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.getTransfer(
-   *   {
-   *     transfer: 'get-transfer-test',
-   *   },
-   *   {
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   transfer: expect.objectContaining({
-   *     identifier: 'get-transfer-test',
-   *     // ...
-   *   }),
-   * });
-   *
-   * ```
-   *
-   */
-  getTransfer(input, options) {
-    return (0, import_get_transfer.getTransfer)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Get information about a specific TransferGroup
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.getTransferGroup(
-   *   {
-   *     transfer_group: 'customIdentifier',
-   *   },
-   *   {
-   *     create_if_not_exists: true,
-   *     // return_only_id: true, // example requires more than just ID
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   transfer_group: expect.objectContaining({
-   *     identifier: 'customIdentifier',
-   *     metadata: null,
-   *     status: 'open',
-   *     transfer_status: 'pending',
-   *     status_finalized_at: null,
-   *     transfer_status_finalized_at: null,
-   *     reverses_id: null,
-   *   }),
-   * });
-   *
-   * ```
-   *
-   */
-  getTransferGroup(input, options) {
-    return (0, import_get_transfer_group.getTransferGroup)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Get information about a specific Wallet
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.getWallet(
-   *   {
-   *     wallet: WALLETS.withEURFunds0.foreign,
-   *   },
-   *   {
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *     ignore_cache: true,
-   *     create_if_not_exists: true,
-   *     return_only_id: false,
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   wallet: expect.objectContaining({
-   *     foreign: WALLETS.withEURFunds0.foreign,
-   *   }),
-   * });
-   *
-   * ```
-   *
-   */
-  getWallet(input, options) {
-    return (0, import_get_wallet.getWallet)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Get information about the health of the API
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.healthcheck();
-   * expect(result.status).toEqual('green');
-   * expect(result.connection_count).toEqual(1);
-   * expect(typeof result.database_size).toEqual('string');
-   * expect(typeof result.indexes_size).toEqual('string');
-   *
-   * ```
-   *
-   */
-  healthcheck(input, options) {
-    return (0, import_healthcheck.healthcheck)({ client: this }, input != null ? input : {}, options);
-  }
-  /**
-   *
-   *  List Export entities by type or time
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.listExports(
-   *   {
-   *     type: 'transfers',
-   *   },
-   *   {
-   *     order_by: 'created_at desc',
-   *     tracking_id: 'myLogId',
-   *   },
-   * );
-   *
-   * ```
-   *
-   */
-  listExports(input, options) {
-    return (0, import_list_exports.listExports)({ client: this }, input != null ? input : {}, options);
-  }
-  /**
-      *
-      *  Reverse a transfer of value between two wallets
-   will cancel pending transfers and create opposite transfers for finished ones.
-      * 
-     *
-       * ```javascript
-       *
-     * const result = await wapiClient.reverseTransfer(
-     *   {
-     *     transfer: 'MYDEPOSIT',
-     *     status: 'finished',
-     *     identifier: 'MYREVERSEDEPOSIT',
-     *     force: true,
-     *     // metadata: {},
-     *     metadata: {
-     *       extraCustomJSON: true,
-     *     },
-     *   },
-     *   {
-     *     reverse_deposit: true,
-     *     reverse_withdrawal: true,
-     *     return_to_balance: true,
-     *     return_from_balance: true,
-     *     metadata_action: 'extend',
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *   },
-     * );
-     * expect(result).toEqual({
-     *   transfer: expect.objectContaining({
-     *     identifier: 'MYREVERSEDEPOSIT',
-     *     amount: 10.01,
-     *     type: 'withdrawal',
-     *     status: 'finished',
-     *     force: true,
-     *     metadata: {
-     *       customJSON: true,
-     *       extraCustomJSON: true,
-     *     },
-     *     transfer_group_id: null,
-     *     reverses_id: DEPOSIT.id,
-     *     from_wallet_foreign: DEPOSIT.to_wallet_foreign,
-     *     to_wallet_foreign: DEPOSIT.from_wallet_foreign,
-     *     token_foreign: DEPOSIT.token_foreign,
-     *     // ...
-     *   }),
-     *   to_balance: expect.objectContaining({
-     *     token_foreign: DEPOSIT.token_foreign,
-     *     wallet_foreign: DEPOSIT.from_wallet_foreign,
-     *     // ...
-     *   }),
-     *   from_balance: expect.objectContaining({
-     *     token_foreign: DEPOSIT.token_foreign,
-     *     wallet_foreign: DEPOSIT.to_wallet_foreign,
-     *     // ...
-     *   }),
-     * });
-     *
-       * ```
-     *
-     */
-  reverseTransfer(input, options) {
-    return (0, import_reverse_transfer.reverseTransfer)({ client: this }, input, options);
-  }
-  /**
-      *
-      *  Similar to reverseTransfer will reverse value transfers, however it will reverse the whole
-   group with its children by creating a new group with opposite transfers.
-      * 
-     *
-       * ```javascript
-       *
-     * // Should succeed if flag is set
-     * const result = await wapiClient.reverseTransferGroup(
-     *   {
-     *     transfer_group: 'myCustom',
-     *     identifier: 'myCustomReverse',
-     *     metadata: {
-     *       extraCustomJSON: true,
-     *     },
-     *     transfer_status: 'finished',
-     *   },
-     *   {
-     *     validate_final_balance_only: true,
-     *     reverse_deposit: true,
-     *     reverse_withdrawal: true,
-     *     return_transfers: true,
-     *     metadata_action: 'extend',
-     *     transfer_metadata_action: 'extend',
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *   },
-     * );
-     *
-     * expect(result).toEqual({
-     *   transfer_group: expect.objectContaining({
-     *     identifier: 'myCustomReverse',
-     *     status: 'closed',
-     *     metadata: {
-     *       customJSON: true,
-     *       extraCustomJSON: true,
-     *     },
-     *     transfer_status: 'finished',
-     *   }),
-     *   transfers: [
-     *     expect.objectContaining({
-     *       from_wallet_foreign: 'myWallet2',
-     *       to_wallet_foreign: 'myWallet1',
-     *       amount: 8,
-     *       type: 'transfer',
-     *       status: 'finished',
-     *       token_foreign: 'EUR',
-     *     }),
-     *     expect.objectContaining({
-     *       from_wallet_foreign: 'myWallet1',
-     *       to_wallet_foreign: 'EUR',
-     *       amount: 10,
-     *       type: 'withdrawal',
-     *       status: 'finished',
-     *       token_foreign: 'EUR',
-     *     }),
-     *   ],
-     * });
-     *
-       * ```
-     *
-     */
-  reverseTransferGroup(input, options) {
-    return (0, import_reverse_transfer_group.reverseTransferGroup)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Call reverseTransfer on the searchresults of findTransfer
-   *
-   *
-   * ```javascript
-   *
-   * const [[finishedTransfer1], [finishedTransfer2]] = await Promise.all([
-   *   TEST.knex('transfers')
-   *     .insert({
-   *       identifier: getTxIdSync(),
-   *       auto_hash: true,
-   *       amount: toNumberInput(10.12),
-   *       status: 'finished',
-   *       metadata: {
-   *         example: 'test',
-   *       },
-   *       from_wallet_id: WALLETS.withEURFunds0.id,
-   *       to_wallet_id: WALLETS.validId1,
-   *       token_id: TOKENS.EUR.id,
-   *     })
-   *     .returning('*'),
-   *   TEST.knex('transfers')
-   *     .insert({
-   *       identifier: getTxIdSync(),
-   *       auto_hash: true,
-   *       amount: toNumberInput(10.12),
-   *       status: 'finished',
-   *       metadata: {
-   *         example: 'test',
-   *       },
-   *       from_wallet_id: WALLETS.withEURFunds0.id,
-   *       to_wallet_id: WALLETS.validId1,
-   *       token_id: TOKENS.EUR.id,
-   *     })
-   *     .returning('*'),
-   * ]);
-   *
-   * const result = await wapiClient.reverseTransfers({
-   *   metadata: {
-   *     example: 'test',
-   *   },
-   * });
-   *
-   * const { transfers } = result;
-   * expect(transfers.length).toEqual(2);
-   *
-   * expect(transfers[0].identifier).not.toEqual(finishedTransfer1.identifier);
-   * expect(transfers[0].amount).toEqual(
-   *   formatNumber(finishedTransfer1.amount),
-   * );
-   * expect(transfers[0].from_wallet_id).toEqual(
-   *   finishedTransfer1.to_wallet_id,
-   * );
-   * expect(transfers[0].to_wallet_id).toEqual(
-   *   finishedTransfer1.from_wallet_id,
-   * );
-   *
-   * expect(transfers[1].identifier).not.toEqual(finishedTransfer2.identifier);
-   * expect(transfers[1].amount).toEqual(
-   *   formatNumber(finishedTransfer2.amount),
-   * );
-   * expect(transfers[1].from_wallet_id).toEqual(
-   *   finishedTransfer2.to_wallet_id,
-   * );
-   * expect(transfers[1].to_wallet_id).toEqual(
-   *   finishedTransfer2.from_wallet_id,
-   * );
-   *
-   * ```
-   *
-   */
-  reverseTransfers(input, options) {
-    return (0, import_reverse_transfers.reverseTransfers)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Configure WAPI instance Flags
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.setFlags(
-   *   {
-   *     production: false,
-   *     allow_timestamps: true,
-   *   },
-   *   {
-   *     tracking_id: 'mylog',
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   flags: {
-   *     production: false,
-   *     allow_timestamps: true,
-   *   },
-   *   message: 'flag updated, reconnect to apply',
-   * });
-   *
-   * ```
-   *
-   */
-  setFlags(input, options) {
-    return (0, import_set_flags.setFlags)({ client: this }, input != null ? input : {}, options);
-  }
-  /**
-   *
-   *  Update a Token
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.updateToken(
-   *   {
-   *     token: TOKENS.EUR.foreign,
-   *     public: false,
-   *     metadata: {
-   *       metadata_field: 2,
-   *     },
-   *     status: 'disabled',
-   *   },
-   *   {
-   *     return_when_not_updated: true,
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   token: expect.objectContaining({
-   *     belongs_to: TOKENS.EUR.belongs_to,
-   *     divisor: TOKENS.EUR.divisor,
-   *     id: TOKENS.EUR.id,
-   *     limit: TOKENS.EUR.limit,
-   *     metadata: {
-   *       metadata_field: 2,
-   *     },
-   *     type: TOKENS.EUR.type,
-   *     foreign: TOKENS.EUR.foreign,
-   *     public: false,
-   *     status: 'disabled',
-   *   }),
-   *   updated: true,
-   * });
-   *
-   * ```
-   *
-   */
-  updateToken(input, options) {
-    return (0, import_update_token.updateToken)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Update an API key
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.updateApikey(
-   *   {
-   *     apikey: 'my-apikey-id',
-   *     metadata: {
-   *       updated: true,
-   *     },
-   *   },
-   *   {
-   *     return_when_not_updated: true,
-   *     tracking_id: 'mylogId',
-   *   },
-   * );
-   *
-   * // Delete an API key
-   * const deleteResult = await wapiClient.updateApikey({
-   *   apikey: 'my-apikey-id',
-   *   status: 'deleted',
-   * });
-   *
-   * // Regenerate apisecret
-   * const regenerateResult = await wapiClient.updateApikey({
-   *   apikey: 'my-apikey-id',
-   *   apisecret: true,
-   * });
-   *
-   * ```
-   *
-   */
-  updateApikey(input, options) {
-    return (0, import_update_apikey.updateApikey)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Update a Transfer
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.updateTransfer(
-   *   {
-   *     transfer: 'myPendingDeposit',
-   *     status: 'cancelled',
-   *     metadata: {
-   *       meta: 'new',
-   *       was: true,
-   *     },
-   *   },
-   *   {
-   *     return_from_balance: true,
-   *     return_to_balance: true,
-   *     return_when_not_updated: true,
-   *     metadata_action: 'extend',
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   transfer: expect.objectContaining({
-   *     identifier: 'myPendingDeposit',
-   *     amount: 10.01,
-   *     type: 'deposit',
-   *     status: 'cancelled',
-   *     transfer_group_id: null,
-   *     reverses_id: null,
-   *     from_wallet_foreign: 'EURO',
-   *     to_wallet_foreign: 'myWallet',
-   *     token_foreign: 'EURO',
-   *     metadata: {
-   *       meta: 'new',
-   *       is: true,
-   *       was: true,
-   *     },
-   *   }),
-   *   to_balance: expect.objectContaining({
-   *     token_foreign: 'EURO',
-   *     wallet_foreign: 'myWallet',
-   *     pending_amount: 0,
-   *     finished_amount: 0,
-   *     amount: 0,
-   *   }),
-   *   from_balance: expect.objectContaining({
-   *     token_foreign: 'EURO',
-   *     wallet_foreign: 'EURO',
-   *     pending_amount: 0,
-   *     finished_amount: 0,
-   *     amount: 0,
-   *   }),
-   *   updated: true,
-   * });
-   *
-   * ```
-   *
-   */
-  updateTransfer(input, options) {
-    return (0, import_update_transfer.updateTransfer)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Update a TransferGroup
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.updateTransferGroup(
-   *   {
-   *     transfer_group: 'myCustom',
-   *     status: 'closed',
-   *     transfer_status: 'finished',
-   *     metadata: {
-   *       newCustomJson: true,
-   *     },
-   *   },
-   *   {
-   *     return_transfers: true,
-   *     return_when_not_updated: true,
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   transfer_group: expect.objectContaining({
-   *     identifier: 'myCustom',
-   *     status: 'closed',
-   *     transfer_status: 'finished',
-   *     metadata: expect.objectContaining({
-   *       newCustomJson: true,
-   *     }),
-   *   }),
-   *   transfers: [
-   *     expect.objectContaining({
-   *       identifier: 'transferA',
-   *       type: 'deposit',
-   *       status: 'finished',
-   *       from_wallet_foreign: 'EUR',
-   *       to_wallet_foreign: 'myWallet1',
-   *       token_foreign: 'EUR',
-   *     }),
-   *     expect.objectContaining({
-   *       identifier: 'transferB',
-   *       type: 'transfer',
-   *       status: 'finished',
-   *       from_wallet_foreign: 'myWallet1',
-   *       to_wallet_foreign: 'myWallet2',
-   *       token_foreign: 'EUR',
-   *     }),
-   *   ],
-   *   updated: true,
-   * });
-   *
-   * ```
-   *
-   */
-  updateTransferGroup(input, options) {
-    return (0, import_update_transfer_group.updateTransferGroup)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Update multiple TransferGroup objects
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient
-   *   .updateTransferGroups()
-   *   .where({
-   *     status: 'open',
-   *   })
-   *   .whereIn('identifier', ['transferGroup1', 'transferGroup2'])
-   *   .whereMetadata('old', 'data')
-   *   .update({
-   *     transfer_status: 'finished',
-   *   })
-   *   .options({
-   *     return_transfers: true,
-   *   });
-   *
-   * ```
-   *
-   */
-  updateTransferGroups(input, options) {
-    return (0, import_update_transfer_groups.updateTransferGroups)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Update multiple Transfer objects
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.updateTransfers({
-   *   metadata: {
-   *     example: 'test',
-   *   },
-   *   wallet: WALLETS.validId1.foreign,
-   *   token: 'EUR',
-   *   update: {
-   *     status: 'finished',
-   *   },
-   * });
-   *
-   * expect(result.transfers.length).toEqual(1);
-   * expect(result.transfers[0].status).toEqual('finished');
-   * expect(result.updated).toEqual(true);
-   *
-   * ```
-   *
-   */
-  updateTransfers(input, options) {
-    return (0, import_update_transfers.updateTransfers)({ client: this }, input, options);
-  }
-  /**
-   *
-   *  Update a Wallet
-   *
-   *
-   * ```javascript
-   *
-   * const result = await wapiClient.updateWallet(
-   *   {
-   *     wallet: WALLETS.withEURFunds0.foreign,
-   *     name: 'WT4',
-   *     status: 'disabled',
-   *     metadata: {
-   *       metadata_number: 2,
-   *     },
-   *   },
-   *   {
-   *     return_when_not_updated: true,
-   *     tracking_id: 'mylogId',
-   *     // transaction_id: Transaction.identifier, // created transaction identifier
-   *   },
-   * );
-   * expect(result).toEqual({
-   *   wallet: expect.objectContaining({
-   *     id: WALLETS.withEURFunds0.id,
-   *     foreign: WALLETS.withEURFunds0.foreign,
-   *     name: 'WT4',
-   *     metadata: { metadata_number: 2 },
-   *     type: WALLETS.withEURFunds0.type,
-   *     status: 'disabled',
-   *     default_allow_negative: false,
-   *     default_allow_positive: true,
-   *     default_dtw_from: '011',
-   *     default_dtw_to: '110',
-   *   }),
-   *   updated: true,
-   * });
-   *
-   * ```
-   *
-   */
-  updateWallet(input, options) {
-    return (0, import_update_wallet.updateWallet)({ client: this }, input, options);
-  }
-  // CLIENTFNDEFS
-};
-function createClientWithWS(opts, config) {
-  const wsClient = (0, import_api.createWsClient)(opts, {
-    connectingTimeout: config == null ? void 0 : config.connectingTimeout,
-    reconnectingTimeout: config == null ? void 0 : config.reconnectingTimeout,
-    connectionName: config == null ? void 0 : config.connectionName
-  });
-  return new Client(wsClient, config);
-}
-function createClientWithHttp(opts, config) {
-  const httpClient = (0, import_api.createHttpClient)(opts, {
-    connectingTimeout: config == null ? void 0 : config.connectingTimeout,
-    reconnectingTimeout: config == null ? void 0 : config.reconnectingTimeout,
-    httpSkipInitialAuthConnection: config == null ? void 0 : config.httpSkipInitialAuthConnection,
-    connectionName: config == null ? void 0 : config.connectionName
-  });
-  return new Client(httpClient, config);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Client,
-  createClientWithHttp,
-  createClientWithWS
-});