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

package/dist/client.cjs

@@ -0,0 +1,2341 @@
+"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
+});