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

package/dist/client.browser.js

@@ -1,2320 +0,0 @@
-var __defProp = Object.defineProperty;
-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 __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
-import {
-  createHttpClient,
-  createWsClient
-} from "./api/index.browser.js";
-import { ConfigError } from "./lib/errors.browser.js";
-import { CLIENT_VERSION } from "./lib/env.browser.js";
-import { aggregateTransfers } from "./fns/aggregate-transfers/aggregate-transfers.browser.js";
-import { createAccessToken } from "./fns/create-access-token/create-access-token.browser.js";
-import { createApikey } from "./fns/create-apikey/create-apikey.browser.js";
-import { createContract } from "./fns/create-contract/create-contract.browser.js";
-import { createDeposit } from "./fns/create-deposit/create-deposit.browser.js";
-import { createExchange } from "./fns/create-exchange/create-exchange.browser.js";
-import { createIndex } from "./fns/create-index/create-index.browser.js";
-import { createToken } from "./fns/create-token/create-token.browser.js";
-import { createTransfer } from "./fns/create-transfer/create-transfer.browser.js";
-import { createTransferGroup } from "./fns/create-transfer-group/create-transfer-group.browser.js";
-import { createTransfers } from "./fns/create-transfers/create-transfers.browser.js";
-import { createWallet } from "./fns/create-wallet/create-wallet.browser.js";
-import { createWithdrawal } from "./fns/create-withdrawal/create-withdrawal.browser.js";
-import { exportBalanceHistory } from "./fns/export-balance-history/export-balance-history.browser.js";
-import { dropIndex } from "./fns/drop-index/drop-index.browser.js";
-import { exportBalances } from "./fns/export-balances/export-balances.browser.js";
-import { exportTokens } from "./fns/export-tokens/export-tokens.browser.js";
-import { exportTransferGroups } from "./fns/export-transfer-groups/export-transfer-groups.browser.js";
-import { exportTransfers } from "./fns/export-transfers/export-transfers.browser.js";
-import { exportWallets } from "./fns/export-wallets/export-wallets.browser.js";
-import { findApikeys } from "./fns/find-apikeys/find-apikeys.browser.js";
-import { findBalances } from "./fns/find-balances/find-balances.browser.js";
-import { findIndexes } from "./fns/find-indexes/find-indexes.browser.js";
-import { findTokens } from "./fns/find-tokens/find-tokens.browser.js";
-import { findTransferGroups } from "./fns/find-transfer-groups/find-transfer-groups.browser.js";
-import { findTransfers } from "./fns/find-transfers/find-transfers.browser.js";
-import { findWallets } from "./fns/find-wallets/find-wallets.browser.js";
-import { getBalance } from "./fns/get-balance/get-balance.browser.js";
-import { getBalanceHistory } from "./fns/get-balance-history/get-balance-history.browser.js";
-import { getExport } from "./fns/get-export/get-export.browser.js";
-import { getFlags } from "./fns/get-flags/get-flags.browser.js";
-import { getStatistics } from "./fns/get-statistics/get-statistics.browser.js";
-import { getToken } from "./fns/get-token/get-token.browser.js";
-import { getTransfer } from "./fns/get-transfer/get-transfer.browser.js";
-import { getTransferGroup } from "./fns/get-transfer-group/get-transfer-group.browser.js";
-import { getWallet } from "./fns/get-wallet/get-wallet.browser.js";
-import { healthcheck } from "./fns/healthcheck/healthcheck.browser.js";
-import { listExports } from "./fns/list-exports/list-exports.browser.js";
-import { reverseTransfer } from "./fns/reverse-transfer/reverse-transfer.browser.js";
-import { reverseTransferGroup } from "./fns/reverse-transfer-group/reverse-transfer-group.browser.js";
-import { reverseTransfers } from "./fns/reverse-transfers/reverse-transfers.browser.js";
-import { setFlags } from "./fns/set-flags/set-flags.browser.js";
-import { updateToken } from "./fns/update-token/update-token.browser.js";
-import { updateApikey } from "./fns/update-apikey/update-apikey.browser.js";
-import { updateTransfer } from "./fns/update-transfer/update-transfer.browser.js";
-import { updateTransferGroup } from "./fns/update-transfer-group/update-transfer-group.browser.js";
-import { updateTransferGroups } from "./fns/update-transfer-groups/update-transfer-groups.browser.js";
-import { updateTransfers } from "./fns/update-transfers/update-transfers.browser.js";
-import { updateWallet } from "./fns/update-wallet/update-wallet.browser.js";
-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 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 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 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 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 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 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 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 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 createExchange({ client: this }, input, options);
-  }
-  /** Create a metadata index. */
-  createIndex(input, options) {
-    return 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 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 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 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 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 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 createWithdrawal({ client: this }, input, options);
-  }
-  /** Drop a metadata index. */
-  dropIndex(input, options) {
-    return 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 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 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 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 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 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 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 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 findBalances({ client: this }, input, options);
-  }
-  /** Search for metadata indexes. */
-  findIndexes(input, options) {
-    return 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 updateWallet({ client: this }, input, options);
-  }
-  // CLIENTFNDEFS
-};
-function createClientWithWS(opts, config) {
-  const wsClient = 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 = 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);
-}
-export {
-  Client,
-  createClientWithHttp,
-  createClientWithWS
-};