wapi-client 0.7.2 → 0.8.1

package/dist/client.browser.cjs

@@ -0,0 +1,1544 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __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_fns = require('./fns/index.cjs');
+var import_import_data = require('./fns/import-data/import-data.guards.cjs');
+var _a;
+var CLIENT_VERSION = (_a = window.WAPI_VERSION) != null ? _a : "";
+var Client = class {
+  /**
+   * @internal
+   */
+  constructor(_apiClient, initialConf) {
+    this.config = {};
+    this.api = _apiClient;
+    this.$connect = _apiClient.$connect;
+    if (initialConf) {
+      if (initialConf.token) {
+        this.config = __spreadProps(__spreadValues({}, this.config), {
+          token: initialConf.token
+        });
+      }
+      if (initialConf.hooks) {
+        for (const [hookName, value] of Object.entries(initialConf.hooks)) {
+          this.setHook(hookName, value);
+        }
+      }
+    }
+  }
+  /**
+   * 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, hooks)
+   *
+   *
+   * ```javascript
+   *
+   * wapiClient.configure({
+   *  token: 'EURO',
+   *  hooks: {
+   *    disconnect: () => {}
+   *  },
+   * });
+   *
+   * ```
+   * @param {ClientConfig} newConf
+   */
+  configure(newConf) {
+    this.config = __spreadValues(__spreadValues({}, this.config), newConf);
+    return this;
+  }
+  /**
+   * Get current config key value (token)
+   * ```javascript
+   *
+   * const token = wapiClient.getConfig('token');
+   *
+   * ```
+   */
+  getConfig(key) {
+    return this.config[key];
+  }
+  aggregateTransfers(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.aggregateTransfers({ client: this });
+    }
+    return import_fns.ClientFunctions.aggregateTransfers({ client: this }, input, options);
+  }
+  /**
+   *
+   *
+   * ```javascript
+   *
+   * const response = await wapiClient.createAccessToken({
+   *   token: {
+   *     type: 'limited',
+   *     scopes: ['getBalance'],
+   *     filters: {
+   *       wallet_foreign: 'user-1-wallet',
+   *       token_foreign: 'EUR',
+   *     },
+   *     expiresIn: 60,
+   *   }
+   * });
+   *
+   * ```
+   *
+   * @param {CreateAccessTokenFnInput} [input]
+   * @param {CreateAccessTokenFnOptions} [options]
+   * @returns {StreamPromise<CreateAccessTokenFnOutput>}
+   *
+   */
+  createAccessToken(input, options) {
+    return import_fns.ClientFunctions.createAccessToken({ client: this }, input, options);
+  }
+  /**
+   *
+   *
+   * ```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',
+   *   },
+   * });
+   *
+   * ```
+   *
+   * @param {CreateContractFnInput} input
+   * @param {CreateContractFnOptions} [options]
+   * @returns {StreamPromise<CreateContractFnOutput>}
+   *
+   */
+  createContract(input, options) {
+    return import_fns.ClientFunctions.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: jasmine.objectContaining({
+   *     identifier: 'mycustomId',
+   *     token_foreign: 'ForeignForToken',
+   *     to_wallet_foreign: 'ForeignForWallet',
+   *     amount: 10.01,
+   *     metadata: {
+   *       customJsonBlob: true,
+   *     },
+   *     status: 'finished',
+   *     // ... other fields
+   *   }),
+   *   to_balance: jasmine.objectContaining({
+   *     token_foreign: 'ForeignForToken',
+   *     wallet_foreign: 'ForeignForWallet',
+   *     pending_amount: 0,
+   *     finished_amount: 10.01,
+   *     amount: 10.01,
+   *     // ... other fields
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {CreateDepositFnInput} input
+   * @param {CreateDepositFnOptions} [options]
+   * @returns {StreamPromise<CreateDepositFnOutput>}
+   *
+   */
+  createDeposit(input, options) {
+    return import_fns.ClientFunctions.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: jasmine.objectContaining({
+   *     identifier: 'exchange',
+   *     status: 'closed',
+   *     transfer_status: 'finished',
+   *   }),
+   *   transfers: [
+   *     jasmine.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',
+   *     }),
+   *     jasmine.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',
+   *     }),
+   *   ],
+   * });
+   *
+   * ```
+   *
+   * @param {CreateExchangeFnInput} input
+   * @param {CreateExchangeFnOptions} [options]
+   * @returns {StreamPromise<CreateExchangeFnOutput>}
+   *
+   */
+  createExchange(input, options) {
+    return import_fns.ClientFunctions.createExchange({ 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: jasmine.objectContaining({
+   *     foreign: 'EURO',
+   *     public: true,
+   *     metadata: {
+   *       customMetadata: true,
+   *     },
+   *   }),
+   *   wallet: jasmine.objectContaining({
+   *     default_allow_positive: false,
+   *     default_allow_negative: true,
+   *     foreign: 'EURO',
+   *     metadata: null,
+   *     type: 'token',
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {CreateTokenFnInput} input
+   * @param {CreateTokenFnOptions} [options]
+   * @returns {StreamPromise<CreateTokenFnOutput>}
+   *
+   */
+  createToken(input, options) {
+    return import_fns.ClientFunctions.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: jasmine.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',
+   *     // ...
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {CreateTransferFnInput} [input]
+   * @param {CreateTransferFnOptions} [options]
+   * @returns {StreamPromise<CreateTransferFnOutput>}
+   *
+   */
+  createTransfer(input, options) {
+    return import_fns.ClientFunctions.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(jasmine.objectContaining({
+   *   transfer_group: jasmine.objectContaining({
+   *     identifier: 'mytgIdentifier',
+   *     status: 'closed',
+   *     metadata: {
+   *       customJSON: true,
+   *     },
+   *     transfer_status: 'finished',
+   *   }),
+   *   transfers: [
+   *     jasmine.objectContaining({
+   *       identifier: 'txIdentifier',
+   *       from_wallet_foreign: WALLETS.withEURFunds0.foreign,
+   *       to_wallet_foreign: 'newWalletForeign',
+   *       token_foreign: 'EUR',
+   *       amount: 10,
+   *       type: 'transfer',
+   *     }),
+   *     jasmine.objectContaining({
+   *       identifier: 'childTgTransferId',
+   *       from_wallet_foreign: 'newWalletForeign',
+   *       to_wallet_foreign: WALLETS.withEURFunds0.foreign,
+   *       token_foreign: 'EUR',
+   *       amount: 9,
+   *       type: 'transfer',
+   *     }),
+   *   ],
+   * }));
+   *
+   *
+   * ```
+   *
+   * @param {CreateTransferGroupFnInput} input
+   * @param {CreateTransferGroupFnOptions} [options]
+   * @returns {StreamPromise<CreateTransferGroupFnOutput>}
+   *
+   */
+  createTransferGroup(input, options) {
+    return import_fns.ClientFunctions.createTransferGroup(
+      { client: this },
+      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(jasmine.objectContaining({
+   *   transfers: [
+   *     jasmine.objectContaining({
+   *       type: 'deposit',
+   *       token_foreign: 'EURO',
+   *       to_wallet_foreign: WALLETS.validForeign2,
+   *       amount: 10.01,
+   *     }),
+   *     jasmine.objectContaining({
+   *       type: 'transfer',
+   *       token_foreign: 'EURO',
+   *       from_wallet_foreign: WALLETS.validForeign2,
+   *       to_wallet_foreign: 'newWalletForeignMby',
+   *       amount: 10.01,
+   *     }),
+   *     jasmine.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: [
+   *     jasmine.objectContaining({
+   *       token_foreign: 'EURO',
+   *       wallet_foreign: 'EURO',
+   *       amount: 0,
+   *     }),
+   *     jasmine.objectContaining({
+   *       token_foreign: 'EURO',
+   *       wallet_foreign: WALLETS.validForeign2,
+   *       amount: 0,
+   *     }),
+   *     jasmine.objectContaining({
+   *       token_foreign: 'EURO',
+   *       wallet_foreign: 'newWalletForeignMby',
+   *       amount: 0,
+   *     }),
+   *   ],
+   *   to_balances: [
+   *     jasmine.objectContaining({
+   *       token_foreign: 'EURO',
+   *       wallet_foreign: WALLETS.validForeign2,
+   *       amount: 0,
+   *     }),
+   *     jasmine.objectContaining({
+   *       token_foreign: 'EURO',
+   *       wallet_foreign: 'newWalletForeignMby',
+   *       amount: 0,
+   *     }),
+   *     jasmine.objectContaining({
+   *       token_foreign: 'EURO',
+   *       wallet_foreign: 'EURO',
+   *       amount: 0,
+   *     }),
+   *   ],
+   * }));
+   *
+   *
+   * ```
+   *
+   * @param {CreateTransfersFnInput} input
+   * @param {CreateTransfersFnOptions} [options]
+   * @returns {StreamPromise<CreateTransfersFnOutput>}
+   *
+   */
+  createTransfers(input, options) {
+    return import_fns.ClientFunctions.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: jasmine.objectContaining({
+   *     foreign: 'test-wallet-2',
+   *     name: 'Irrelevant',
+   *     metadata: {
+   *       awesome: true,
+   *       invalid: false,
+   *     },
+   *   }),
+   * });
+   *
+   *
+   * ```
+   *
+   * @param {CreateWalletFnInput} input
+   * @param {CreateWalletFnOptions} [options]
+   * @returns {StreamPromise<CreateWalletFnOutput>}
+   *
+   */
+  createWallet(input, options) {
+    return import_fns.ClientFunctions.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: jasmine.objectContaining({
+   *     identifier: 'mycustomId',
+   *     token_foreign: 'ForeignForToken',
+   *     from_wallet_foreign: 'ForeignForWallet',
+   *     amount: 10.01,
+   *     metadata: {
+   *       customJsonBlob: true,
+   *     },
+   *     status: 'finished',
+   *     // ... other fields
+   *   }),
+   *   from_balance: jasmine.objectContaining({
+   *     token_foreign: 'ForeignForToken',
+   *     wallet_foreign: 'ForeignForWallet',
+   *     pending_amount: 0,
+   *     finished_amount: 89.99,
+   *     amount: 89.99,
+   *     // ... other fields
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {CreateWithdrawalFnInput} input
+   * @param {CreateWithdrawalFnOptions} [options]
+   * @returns {StreamPromise<CreateWithdrawalFnOutput>}
+   *
+   */
+  createWithdrawal(input, options) {
+    return import_fns.ClientFunctions.createWithdrawal({ client: this }, input, options);
+  }
+  findBalances(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.findBalances({ client: this });
+    }
+    return import_fns.ClientFunctions.findBalances({ client: this }, input, options);
+  }
+  findTokens(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.findTokens({ client: this });
+    }
+    return import_fns.ClientFunctions.findTokens({ client: this }, input, options);
+  }
+  findTransferGroups(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.findTransferGroups({ client: this });
+    }
+    return import_fns.ClientFunctions.findTransferGroups({ client: this }, input, options);
+  }
+  findTransfers(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.findTransfers({ client: this });
+    }
+    return import_fns.ClientFunctions.findTransfers({ client: this }, input, options);
+  }
+  findWallets(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.findWallets({ client: this });
+    }
+    return import_fns.ClientFunctions.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: jasmine.objectContaining({
+   *     wallet_foreign: 'myMbyExistingWallet',
+   *     token_foreign: 'MBYTOKEN',
+   *     pending_amount: 0,
+   *     finished_amount: 0,
+   *     amount: 0,
+   *     latest_control_hash: null,
+   *     available_balance: 0,
+   *     // ...
+   *   }),
+   * });
+   *
+   *
+   * ```
+   *
+   * @param {GetBalanceFnInput} input
+   * @param {GetBalanceFnOptions} [options]
+   * @returns {StreamPromise<GetBalanceFnOutput>}
+   *
+   */
+  getBalance(input, options) {
+    return import_fns.ClientFunctions.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,
+   *   },
+   * });
+   *
+   * ```
+   *
+   * @param {GetBalanceHistoryFnInput} input
+   * @param {GetBalanceHistoryFnOptions} [options]
+   * @returns {StreamPromise<GetBalanceHistoryFnOutput>}
+   *
+   */
+  getBalanceHistory(input, options) {
+    return import_fns.ClientFunctions.getBalanceHistory({ 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,
+   * });
+   *
+   * ```
+   *
+   * @param {GetFlagsFnInput} [input]
+   * @param {GetFlagsFnOptions} [options]
+   * @returns {StreamPromise<GetFlagsFnOutput>}
+   *
+   */
+  getFlags(input, options) {
+    return import_fns.ClientFunctions.getFlags({ client: this }, input, options);
+  }
+  /**
+   *
+   * Get aggregated statistics about WAPI entities
+   *
+   * ```javascript
+   *
+   * const result = await wapiClient.getStatistics({
+   *   model: 'Transfer',
+   *   aggregator: 'count',
+   *   groups: [{
+   *     type: 'period',
+   *     field: {
+   *       period: '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: 3,
+   *       period: `${new Date().getFullYear()}-${(new Date().getMonth() + 1 + '').padStart(2, '0')}`,
+   *     },
+   *   ],
+   * });
+   *
+   * ```
+   *
+   * @param {GetStatisticsFnInput} [input]
+   * @param {GetStatisticsFnOptions} [options]
+   * @returns {StreamPromise<GetStatisticsFnOutput>}
+   *
+   */
+  getStatistics(input, options) {
+    return import_fns.ClientFunctions.getStatistics({ client: this }, input, options);
+  }
+  /**
+   *
+   * Get information about token
+   *
+   * ```javascript
+   *
+   * const result = await wapiClient.getToken({
+   *   foreign: 'EURO',
+   * }, {
+   *   create_if_not_exists: true,
+   *   // return_only_id: true, // for example purposes we want more than id
+   *   ignore_cache: true,
+   *   tracking_id: 'mylogId',
+   *   // transaction_id: Transaction.identifier, // created transaction identifier
+   * });
+   *
+   * expect(result).toEqual({
+   *   token: jasmine.objectContaining({
+   *     foreign: 'EURO',
+   *     metadata: null,
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {GetTokenFnInput} [input]
+   * @param {GetTokenFnOptions} [options]
+   * @returns {StreamPromise<GetTokenFnOutput>}
+   *
+   */
+  getToken(input, options) {
+    return import_fns.ClientFunctions.getToken({ client: this }, 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: jasmine.objectContaining({
+   *     identifier: 'get-transfer-test',
+   *     // ...
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {GetTransferFnInput} input
+   * @param {GetTransferFnOptions} [options]
+   * @returns {StreamPromise<GetTransferFnOutput>}
+   *
+   */
+  getTransfer(input, options) {
+    return import_fns.ClientFunctions.getTransfer({ client: this }, input, options);
+  }
+  /**
+   *
+   * Get TransferGroup information
+   *
+   * ```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: jasmine.objectContaining({
+   *     identifier: 'customIdentifier',
+   *     metadata: null,
+   *     status: 'open',
+   *     transfer_status: 'pending',
+   *     status_finalized_at: null,
+   *     transfer_status_finalized_at: null,
+   *     reverses_id: null,
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {GetTransferGroupFnInput} input
+   * @param {GetTransferGroupFnOptions} [options]
+   * @returns {StreamPromise<GetTransferGroupFnOutput>}
+   *
+   */
+  getTransferGroup(input, options) {
+    return import_fns.ClientFunctions.getTransferGroup({ client: this }, input, options);
+  }
+  /**
+   *
+   * Get information about 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: jasmine.objectContaining({
+   *     foreign: WALLETS.withEURFunds0.foreign,
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {GetWalletFnInput} input
+   * @param {GetWalletFnOptions} [options]
+   * @returns {StreamPromise<GetWalletFnOutput>}
+   *
+   */
+  getWallet(input, options) {
+    return import_fns.ClientFunctions.getWallet({ client: this }, input, options);
+  }
+  importData(input, options) {
+    if (input === void 0 && options === void 0) {
+      return import_fns.ClientFunctions.importData({ client: this });
+    }
+    if (options === void 0 && (0, import_import_data.isImportDataFnOptions)(input)) {
+      return import_fns.ClientFunctions.importData({ client: this }, input);
+    }
+    if ((0, import_import_data.isImportDataFnInput)(input)) {
+      return import_fns.ClientFunctions.importData({ client: this }, input, options);
+    }
+    throw new import_errors.ValidationError({
+      message: import_errors.ERROR_MESSAGES.INPUT_INVALID,
+      data: {
+        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: jasmine.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: jasmine.objectContaining({
+   *     token_foreign: DEPOSIT.token_foreign,
+   *     wallet_foreign: DEPOSIT.from_wallet_foreign,
+   *     // ...
+   *   }),
+   *   from_balance: jasmine.objectContaining({
+   *     token_foreign: DEPOSIT.token_foreign,
+   *     wallet_foreign: DEPOSIT.to_wallet_foreign,
+   *     // ...
+   *   }),
+   * });
+   *
+   * ```
+   *
+   * @param {ReverseTransferFnInput} input
+   * @param {ReverseTransferFnOptions} [options]
+   * @returns {StreamPromise<ReverseTransferFnOutput>}
+   *
+   */
+  reverseTransfer(input, options) {
+    return import_fns.ClientFunctions.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: jasmine.objectContaining({
+   *     identifier: 'myCustomReverse',
+   *     status: 'closed',
+   *     metadata: {
+   *       customJSON: true,
+   *       extraCustomJSON: true,
+   *     },
+   *     transfer_status: 'finished',
+   *   }),
+   *   transfers: [
+   *     jasmine.objectContaining({
+   *       from_wallet_foreign: 'myWallet2',
+   *       to_wallet_foreign: 'myWallet1',
+   *       amount: 8,
+   *       type: 'transfer',
+   *       status: 'finished',
+   *       token_foreign: 'EUR',
+   *     }),
+   *     jasmine.objectContaining({
+   *       from_wallet_foreign: 'myWallet1',
+   *       to_wallet_foreign: 'EUR',
+   *       amount: 10,
+   *       type: 'withdrawal',
+   *       status: 'finished',
+   *       token_foreign: 'EUR',
+   *     }),
+   *   ],
+   * });
+   *
+   * ```
+   *
+   * @param {ReverseTransferGroupFnInput} input
+   * @param {ReverseTransferGroupFnOptions} [options]
+   * @returns {StreamPromise<ReverseTransferGroupFnOutput>}
+   *
+   */
+  reverseTransferGroup(input, options) {
+    return import_fns.ClientFunctions.reverseTransferGroup(
+      { client: this },
+      input,
+      options
+    );
+  }
+  reverseTransfers(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.reverseTransfers({ client: this });
+    }
+    return import_fns.ClientFunctions.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',
+   * });
+   *
+   * ```
+   *
+   * @param {SetFlagsFnInput} input
+   * @param {SetFlagsFnOptions} [options]
+   * @returns {StreamPromise<SetFlagsFnOutput>}
+   *
+   */
+  setFlags(input, options) {
+    return import_fns.ClientFunctions.setFlags({ client: this }, input, options);
+  }
+  /**
+   * Update token object
+   *
+   * ```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: jasmine.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,
+   * });
+   *
+   * ```
+   *
+   * @param {UpdateTokenFnInput} input
+   * @param {UpdateTokenFnOptions} [options]
+   * @returns {StreamPromise<UpdateTokenFnOutput>}
+   *
+   */
+  updateToken(input, options) {
+    return import_fns.ClientFunctions.updateToken({ client: this }, input, options);
+  }
+  /**
+   *
+   * Update the status of a Transfer (pending to finished or cancelled)
+   *
+   * ```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: jasmine.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: jasmine.objectContaining({
+   *     token_foreign: 'EURO',
+   *     wallet_foreign: 'myWallet',
+   *     pending_amount: 0,
+   *     finished_amount: 0,
+   *     amount: 0,
+   *   }),
+   *   from_balance: jasmine.objectContaining({
+   *     token_foreign: 'EURO',
+   *     wallet_foreign: 'EURO',
+   *     pending_amount: 0,
+   *     finished_amount: 0,
+   *     amount: 0,
+   *   }),
+   *   updated: true,
+   * });
+   *
+   * ```
+   *
+   * @param {UpdateTransferFnInput} input
+   * @param {UpdateTransferFnOptions} [options]
+   * @returns {StreamPromise<UpdateTransferFnOutput>}
+   *
+   */
+  updateTransfer(input, options) {
+    return import_fns.ClientFunctions.updateTransfer({ client: this }, input, options);
+  }
+  /**
+   *
+   * Update the status and transfer_status of a TransferGroup
+   *
+   * ```javascript
+   *
+   * const result = await wapiClient.updateTransferGroup({
+   *   transfer_group: 'myCustom',
+   *   status: 'closed',
+   *   transfer_status: 'finished',
+   * }, {
+   *   return_transfers: true,
+   *   return_when_not_updated: true,
+   *   tracking_id: 'mylogId',
+   *   // transaction_id: Transaction.identifier, // created transaction identifier
+   * });
+   * expect(result).toEqual({
+   *   transfer_group: jasmine.objectContaining({
+   *     identifier: 'myCustom',
+   *     status: 'closed',
+   *     transfer_status: 'finished',
+   *   }),
+   *   transfers: [
+   *     jasmine.objectContaining({
+   *       identifier: 'transferA',
+   *       type: 'deposit',
+   *       status: 'finished',
+   *       from_wallet_foreign: 'EUR',
+   *       to_wallet_foreign: 'myWallet1',
+   *       token_foreign: 'EUR',
+   *     }),
+   *     jasmine.objectContaining({
+   *       identifier: 'transferB',
+   *       type: 'transfer',
+   *       status: 'finished',
+   *       from_wallet_foreign: 'myWallet1',
+   *       to_wallet_foreign: 'myWallet2',
+   *       token_foreign: 'EUR',
+   *     }),
+   *   ],
+   *   updated: true,
+   * });
+   *
+   * ```
+   *
+   * @param {UpdateTransferGroupFnInput} input
+   * @param {UpdateTransferGroupFnOptions} [options]
+   * @returns {StreamPromise<UpdateTransferGroupFnOutput>}
+   *
+   */
+  updateTransferGroup(input, options) {
+    return import_fns.ClientFunctions.updateTransferGroup(
+      { client: this },
+      input,
+      options
+    );
+  }
+  updateTransferGroups(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.updateTransferGroups({ client: this });
+    }
+    return import_fns.ClientFunctions.updateTransferGroups(
+      { client: this },
+      input,
+      options
+    );
+  }
+  updateTransfers(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.updateTransfers({ client: this });
+    }
+    return import_fns.ClientFunctions.updateTransfers({ client: this }, input, options);
+  }
+  /**
+   * Update 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: jasmine.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,
+   * });
+   *
+   * ```
+   *
+   * @param {UpdateWalletFnInput} input
+   * @param {UpdateWalletFnOptions} [options]
+   * @returns {StreamPromise<UpdateWalletFnOutput>}
+   *
+   */
+  updateWallet(input, options) {
+    return import_fns.ClientFunctions.updateWallet({ client: this }, input, options);
+  }
+  // CLIENTFNDEFS
+};
+function createClientWithWS(opts, config) {
+  const wsClient = (0, import_api.createWsClient)(opts);
+  return new Client(wsClient, config);
+}
+function createClientWithHttp(opts, config) {
+  const httpClient = (0, import_api.createHttpClient)(opts);
+  return new Client(httpClient, config);
+}