wapi-client 0.9.5 → 0.10.0

package/dist/client.browser.cjs

@@ -185,7 +185,7 @@ var Client = class {
    *       token_foreign: 'EUR',
    *     },
    *     expiresIn: 60,
-   *   }
+   *   },
    * });
    *
    * ```
@@ -196,7 +196,11 @@ var Client = class {
    *
    */
   createAccessToken(input, options) {
-    return import_fns.ClientFunctions.createAccessToken({ client: this }, input, options);
+    return import_fns.ClientFunctions.createAccessToken(
+      { client: this },
+      input != null ? input : {},
+      options
+    );
   }
   /**
    *
@@ -237,25 +241,28 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.createDeposit({
-   *   identifier: 'mycustomId',
-   *   token: 'ForeignForToken',
-   *   wallet: 'ForeignForWallet',
-   *   amount: 10.01,
-   *   metadata: {
-   *     customJsonBlob: true,
+   * 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
    *   },
-   *   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,
-   * });
+   *   {
+   *     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({
+   *   transfer: expect.objectContaining({
    *     identifier: 'mycustomId',
    *     token_foreign: 'ForeignForToken',
    *     to_wallet_foreign: 'ForeignForWallet',
@@ -266,7 +273,7 @@ var Client = class {
    *     status: 'finished',
    *     // ... other fields
    *   }),
-   *   to_balance: jasmine.objectContaining({
+   *   to_balance: expect.objectContaining({
    *     token_foreign: 'ForeignForToken',
    *     wallet_foreign: 'ForeignForWallet',
    *     pending_amount: 0,
@@ -293,32 +300,35 @@ var Client = class {
    *
    * ```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,
+   * 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
-   * });
+   *   {
+   *     tracking_id: 'mylogId',
+   *     // transaction_id: Transaction.identifier, // created transaction identifier
+   *   },
+   * );
    * expect(result).toEqual({
-   *   transfer_group: jasmine.objectContaining({
+   *   transfer_group: expect.objectContaining({
    *     identifier: 'exchange',
    *     status: 'closed',
    *     transfer_status: 'finished',
    *   }),
    *   transfers: [
-   *     jasmine.objectContaining({
+   *     expect.objectContaining({
    *       status: 'finished',
    *       amount: 10,
    *       from_wallet_id: WALLETS.withEURFunds0.id,
@@ -329,7 +339,7 @@ var Client = class {
    *       },
    *       identifier: 'exchange1',
    *     }),
-   *     jasmine.objectContaining({
+   *     expect.objectContaining({
    *       status: 'finished',
    *       amount: 20,
    *       to_wallet_id: WALLETS.withEURFunds0.id,
@@ -377,14 +387,14 @@ var Client = class {
    * );
    *
    * expect(result).toEqual({
-   *   token: jasmine.objectContaining({
+   *   token: expect.objectContaining({
    *     foreign: 'EURO',
    *     public: true,
    *     metadata: {
    *       customMetadata: true,
    *     },
    *   }),
-   *   wallet: jasmine.objectContaining({
+   *   wallet: expect.objectContaining({
    *     default_allow_positive: false,
    *     default_allow_negative: true,
    *     foreign: 'EURO',
@@ -409,26 +419,29 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.createTransfer({
-   *   identifier: 'mynewtransferid',
-   *   token: 'EUR',
-   *   from_wallet: WALLETS.withEURFunds0.foreign,
-   *   to_wallet: 'foreignForMbyExistingWallet',
-   *   amount: 10.01,
-   *   metadata: {
-   *     customJSON: true,
+   * 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,
    *   },
-   *   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
-   * });
+   *   {
+   *     create_to_wallet_if_not_exists: true,
+   *     tracking_id: 'mylogId',
+   *     // transaction_id: Transaction.identifier, // created transaction identifier
+   *   },
+   * );
    *
    * expect(result).toEqual({
-   *   transfer: jasmine.objectContaining({
+   *   transfer: expect.objectContaining({
    *     identifier: 'mynewtransferid',
    *     token_foreign: 'EUR',
    *     from_wallet_foreign: WALLETS.withEURFunds0.foreign,
@@ -445,7 +458,7 @@ var Client = class {
    *
    * ```
    *
-   * @param {CreateTransferFnInput} [input]
+   * @param {CreateTransferFnInput} input
    * @param {CreateTransferFnOptions} [options]
    * @returns {StreamPromise<CreateTransferFnOutput>}
    *
@@ -462,69 +475,75 @@ var Client = class {
    *
    * ```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({
+   * const result = await wapiClient.createTransferGroup(
+   *   {
    *     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',
+   *     // 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',
+   *       }),
+   *     ],
+   *   }),
+   * );
    *
    *
    * ```
@@ -548,91 +567,100 @@ var Client = class {
    *
    * ```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
-   * });
+   * 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,
-   *     }),
-   *   ],
-   * }));
+   * 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,
+   *       }),
+   *     ],
+   *   }),
+   * );
    *
    *
    * ```
@@ -651,20 +679,23 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.createWallet({
-   *   foreign: 'test-wallet-2',
-   *   name: 'Irrelevant',
-   *   metadata: {
-   *     awesome: true,
-   *     invalid: false,
+   * 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
-   * });
+   *   {
+   *     tracking_id: 'mylogId',
+   *     // transaction_id: Transaction.identifier, // created transaction identifier
+   *   },
+   * );
    *
    * expect(result).toEqual({
-   *   wallet: jasmine.objectContaining({
+   *   wallet: expect.objectContaining({
    *     foreign: 'test-wallet-2',
    *     name: 'Irrelevant',
    *     metadata: {
@@ -692,25 +723,28 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.createWithdrawal({
-   *   identifier: 'mycustomId',
-   *   token: 'ForeignForToken',
-   *   wallet: 'ForeignForWallet',
-   *   amount: 10.01,
-   *   metadata: {
-   *     customJsonBlob: true,
+   * 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
    *   },
-   *   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,
-   * });
+   *   {
+   *     tracking_id: 'mylogId',
+   *     // transaction_id: Transaction.identifier, // created transaction identifier
+   *     return_balance: true,
+   *   },
+   * );
    *
    * expect(result).toEqual({
-   *   transfer: jasmine.objectContaining({
+   *   transfer: expect.objectContaining({
    *     identifier: 'mycustomId',
    *     token_foreign: 'ForeignForToken',
    *     from_wallet_foreign: 'ForeignForWallet',
@@ -721,7 +755,7 @@ var Client = class {
    *     status: 'finished',
    *     // ... other fields
    *   }),
-   *   from_balance: jasmine.objectContaining({
+   *   from_balance: expect.objectContaining({
    *     token_foreign: 'ForeignForToken',
    *     wallet_foreign: 'ForeignForWallet',
    *     pending_amount: 0,
@@ -741,6 +775,50 @@ var Client = class {
   createWithdrawal(input, options) {
     return import_fns.ClientFunctions.createWithdrawal({ client: this }, input, options);
   }
+  /**
+   *
+   *
+   *
+   * @param {ExportBalanceHistoryFnInput} input
+   * @param {ExportBalanceHistoryFnOptions} [options]
+   * @returns {StreamPromise<ExportBalanceHistoryFnOutput>}
+   *
+   */
+  exportBalanceHistory(input, options) {
+    return import_fns.ClientFunctions.exportBalanceHistory(
+      { client: this },
+      input,
+      options
+    );
+  }
+  exportTokens(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.exportTokens({ client: this });
+    }
+    return import_fns.ClientFunctions.exportTokens({ client: this }, input, options);
+  }
+  exportTransferGroups(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.exportTransferGroups({ client: this });
+    }
+    return import_fns.ClientFunctions.exportTransferGroups(
+      { client: this },
+      input,
+      options
+    );
+  }
+  exportTransfers(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.exportTransfers({ client: this });
+    }
+    return import_fns.ClientFunctions.exportTransfers({ client: this }, input, options);
+  }
+  exportWallets(input, options) {
+    if (input === void 0) {
+      return import_fns.ClientFunctions.exportWallets({ client: this });
+    }
+    return import_fns.ClientFunctions.exportWallets({ client: this }, input, options);
+  }
   findBalances(input, options) {
     if (input === void 0) {
       return import_fns.ClientFunctions.findBalances({ client: this });
@@ -777,20 +855,23 @@ var Client = class {
    *
    * ```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
-   * });
+   * 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({
+   *   balance: expect.objectContaining({
    *     wallet_foreign: 'myMbyExistingWallet',
    *     token_foreign: 'MBYTOKEN',
    *     pending_amount: 0,
@@ -820,66 +901,72 @@ var Client = class {
    * ```javascript
    *
    * // setup
-   * const deposit = await wapiClient.createDeposit({
-   *   wallet: 'newWallet',
-   *   amount: 10,
-   *   status: 'pending',
-   *   identifier: 'depositUSD',
-   *   token: 'USD',
-   * }, {
-   *   create_wallet_if_not_exists: true,
-   * });
+   * 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
-   * });
+   * 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: [
    *     {
@@ -917,6 +1004,32 @@ var Client = class {
   getBalanceHistory(input, options) {
     return import_fns.ClientFunctions.getBalanceHistory({ client: this }, input, options);
   }
+  /**
+   *
+   * Get a specific token/wallet balance
+   *
+   * ```javascript
+   *
+   * const result = await wapiClient.getExport(
+   *   {
+   *     identifier: exportingResult.export.identifier,
+   *   },
+   *   {
+   *     return_signed_url: true,
+   *     tracking_id: 'myLogId',
+   *   },
+   * );
+   *
+   * ```
+   *
+   * @param {GetExportFnInput} input
+   * @param {GetExportFnOptions} [options]
+   * @returns {StreamPromise<GetExportFnOutput>}
+   *
+   */
+  getExport(input, options) {
+    return import_fns.ClientFunctions.getExport({ client: this }, input, options);
+  }
   /**
    *
    * Retrieve the current state of configurable Flags for your WAPI instance
@@ -937,7 +1050,7 @@ var Client = class {
    *
    */
   getFlags(input, options) {
-    return import_fns.ClientFunctions.getFlags({ client: this }, input, options);
+    return import_fns.ClientFunctions.getFlags({ client: this }, input != null ? input : {}, options);
   }
   /**
    *
@@ -945,29 +1058,38 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.getStatistics({
-   *   model: 'Transfer',
-   *   aggregator: 'count',
-   *   groups: [{
-   *     type: 'period',
-   *     field: {
-   *       period: 'month',
-   *       timezone: 'Europe/Tallinn',
+   * 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(),
    *     },
-   *   }],
-   *   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
-   * });
+   *   {
+   *     tracking_id: 'mylogId',
+   *     // transaction_id: Transaction.identifier, // created transaction identifier
+   *   },
+   * );
    *
    * expect(result).toEqual({
    *   rows: [
    *     {
-   *       aggregate: 3,
+   *       aggregate: 4,
    *       period: `${new Date().getFullYear()}-${(new Date().getMonth() + 1 + '').padStart(2, '0')}`,
    *     },
    *   ],
@@ -981,7 +1103,11 @@ var Client = class {
    *
    */
   getStatistics(input, options) {
-    return import_fns.ClientFunctions.getStatistics({ client: this }, input, options);
+    return import_fns.ClientFunctions.getStatistics(
+      { client: this },
+      input != null ? input : {},
+      options
+    );
   }
   /**
    *
@@ -989,20 +1115,27 @@ var Client = class {
    *
    * ```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
-   * });
+   * 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,
+   *     include_balance: true,
+   *     tracking_id: 'mylogId',
+   *     // transaction_id: Transaction.identifier, // created transaction identifier
+   *   },
+   * );
    *
    * expect(result).toEqual({
-   *   token: jasmine.objectContaining({
+   *   token: expect.objectContaining({
    *     foreign: 'EURO',
    *     metadata: null,
+   *     balance_amount: null,
+   *     balance_finished_amount: null,
+   *     balance_updated_at: null,
    *   }),
    * });
    *
@@ -1014,7 +1147,7 @@ var Client = class {
    *
    */
   getToken(input, options) {
-    return import_fns.ClientFunctions.getToken({ client: this }, input, options);
+    return import_fns.ClientFunctions.getToken({ client: this }, input != null ? input : {}, options);
   }
   /**
    *
@@ -1022,14 +1155,17 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.getTransfer({
-   *   transfer: 'get-transfer-test',
-   * }, {
-   *   tracking_id: 'mylogId',
-   *   // transaction_id: Transaction.identifier, // created transaction identifier
-   * });
+   * 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({
+   *   transfer: expect.objectContaining({
    *     identifier: 'get-transfer-test',
    *     // ...
    *   }),
@@ -1051,16 +1187,19 @@ var Client = class {
    *
    * ```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
-   * });
+   * 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({
+   *   transfer_group: expect.objectContaining({
    *     identifier: 'customIdentifier',
    *     metadata: null,
    *     status: 'open',
@@ -1087,17 +1226,20 @@ var Client = class {
    *
    * ```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,
-   * });
+   * 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({
+   *   wallet: expect.objectContaining({
    *     foreign: WALLETS.withEURFunds0.foreign,
    *   }),
    * });
@@ -1114,24 +1256,19 @@ var Client = class {
   }
   /**
    *
-   * Get health information about service
+   * Get information about wallet
    *
    * ```javascript
    *
-   * const result = await wapiClient.healthcheck({
-   * }, {
-   *   tracking_id: 'mylogId',
-   * });
-   * expect(result).toEqual({
-   *   status: 'green',
-   *   database_size: '3240MB',
-   *   indexes_size: '1234MB',
-   *   connection_count: 1,
-   * });
+   * 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');
    *
    * ```
    *
-   * @param {HealthcheckFnInput} input
+   * @param {HealthcheckFnInput} [input]
    * @param {HealthcheckFnOptions} [options]
    * @returns {StreamPromise<HealthcheckFnOutput>}
    *
@@ -1154,6 +1291,30 @@ var Client = class {
       options
     });
   }
+  /**
+   *
+   * Search for Balances using either a simple filter or queryBuilder
+   *
+   *
+   * ```javascript
+   *
+   * const result = await wapiClient.listExports(
+   *   {},
+   *   {
+   *     tracking_id: 'myLogId',
+   *   },
+   * );
+   *
+   * ```
+   *
+   * @param {ListExportsFnInput} [input]
+   * @param {ListExportsFnOptions} [options]
+   * @returns {StreamPromise<ListExportsFnOutput>}
+   *
+   */
+  listExports(input, options) {
+    return import_fns.ClientFunctions.listExports({ client: this }, input != null ? input : {}, options);
+  }
   /**
    *
    * Reverse a transfer of value between two wallets
@@ -1161,26 +1322,29 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.reverseTransfer({
-   *   transfer: 'MYDEPOSIT',
-   *   status: 'finished',
-   *   identifier: 'MYREVERSEDEPOSIT',
-   *   force: true,
-   *   // metadata: {},
-   *   metadata: {
-   *     extraCustomJSON: true,
+   * 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
-   * });
+   *   {
+   *     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({
+   *   transfer: expect.objectContaining({
    *     identifier: 'MYREVERSEDEPOSIT',
    *     amount: 10.01,
    *     type: 'withdrawal',
@@ -1197,12 +1361,12 @@ var Client = class {
    *     token_foreign: DEPOSIT.token_foreign,
    *     // ...
    *   }),
-   *   to_balance: jasmine.objectContaining({
+   *   to_balance: expect.objectContaining({
    *     token_foreign: DEPOSIT.token_foreign,
    *     wallet_foreign: DEPOSIT.from_wallet_foreign,
    *     // ...
    *   }),
-   *   from_balance: jasmine.objectContaining({
+   *   from_balance: expect.objectContaining({
    *     token_foreign: DEPOSIT.token_foreign,
    *     wallet_foreign: DEPOSIT.to_wallet_foreign,
    *     // ...
@@ -1227,26 +1391,29 @@ var Client = class {
    * ```javascript
    *
    * // Should succeed if flag is set
-   * const result = await wapiClient.reverseTransferGroup({
-   *   transfer_group: 'myCustom',
-   *   identifier: 'myCustomReverse',
-   *   metadata: {
-   *     extraCustomJSON: true,
+   * const result = await wapiClient.reverseTransferGroup(
+   *   {
+   *     transfer_group: 'myCustom',
+   *     identifier: 'myCustomReverse',
+   *     metadata: {
+   *       extraCustomJSON: true,
+   *     },
+   *     transfer_status: 'finished',
    *   },
-   *   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
-   * });
+   *   {
+   *     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({
+   *   transfer_group: expect.objectContaining({
    *     identifier: 'myCustomReverse',
    *     status: 'closed',
    *     metadata: {
@@ -1256,7 +1423,7 @@ var Client = class {
    *     transfer_status: 'finished',
    *   }),
    *   transfers: [
-   *     jasmine.objectContaining({
+   *     expect.objectContaining({
    *       from_wallet_foreign: 'myWallet2',
    *       to_wallet_foreign: 'myWallet1',
    *       amount: 8,
@@ -1264,7 +1431,7 @@ var Client = class {
    *       status: 'finished',
    *       token_foreign: 'EUR',
    *     }),
-   *     jasmine.objectContaining({
+   *     expect.objectContaining({
    *       from_wallet_foreign: 'myWallet1',
    *       to_wallet_foreign: 'EUR',
    *       amount: 10,
@@ -1301,12 +1468,15 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.setFlags({
-   *   production: false,
-   *   allow_timestamps: true,
-   * }, {
-   *   tracking_id: 'mylog',
-   * });
+   * const result = await wapiClient.setFlags(
+   *   {
+   *     production: false,
+   *     allow_timestamps: true,
+   *   },
+   *   {
+   *     tracking_id: 'mylog',
+   *   },
+   * );
    * expect(result).toEqual({
    *   flags: {
    *     production: false,
@@ -1346,7 +1516,7 @@ var Client = class {
    *   },
    * );
    * expect(result).toEqual({
-   *   token: jasmine.objectContaining({
+   *   token: expect.objectContaining({
    *     belongs_to: TOKENS.EUR.belongs_to,
    *     divisor: TOKENS.EUR.divisor,
    *     id: TOKENS.EUR.id,
@@ -1378,23 +1548,26 @@ var Client = class {
    *
    * ```javascript
    *
-   * const result = await wapiClient.updateTransfer({
-   *   transfer: 'myPendingDeposit',
-   *   status: 'cancelled',
-   *   metadata: {
-   *     meta: 'new',
-   *     was: true,
+   * 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
-   * });
+   *   {
+   *     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({
+   *   transfer: expect.objectContaining({
    *     identifier: 'myPendingDeposit',
    *     amount: 10.01,
    *     type: 'deposit',
@@ -1408,16 +1581,16 @@ var Client = class {
    *       meta: 'new',
    *       is: true,
    *       was: true,
-   *     }
+   *     },
    *   }),
-   *   to_balance: jasmine.objectContaining({
+   *   to_balance: expect.objectContaining({
    *     token_foreign: 'EURO',
    *     wallet_foreign: 'myWallet',
    *     pending_amount: 0,
    *     finished_amount: 0,
    *     amount: 0,
    *   }),
-   *   from_balance: jasmine.objectContaining({
+   *   from_balance: expect.objectContaining({
    *     token_foreign: 'EURO',
    *     wallet_foreign: 'EURO',
    *     pending_amount: 0,
@@ -1443,24 +1616,33 @@ var Client = class {
    *
    * ```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
-   * });
+   * 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: jasmine.objectContaining({
+   *   transfer_group: expect.objectContaining({
    *     identifier: 'myCustom',
    *     status: 'closed',
    *     transfer_status: 'finished',
+   *     metadata: expect.objectContaining({
+   *       newCustomJson: true,
+   *     }),
    *   }),
    *   transfers: [
-   *     jasmine.objectContaining({
+   *     expect.objectContaining({
    *       identifier: 'transferA',
    *       type: 'deposit',
    *       status: 'finished',
@@ -1468,7 +1650,7 @@ var Client = class {
    *       to_wallet_foreign: 'myWallet1',
    *       token_foreign: 'EUR',
    *     }),
-   *     jasmine.objectContaining({
+   *     expect.objectContaining({
    *       identifier: 'transferB',
    *       type: 'transfer',
    *       status: 'finished',
@@ -1531,11 +1713,11 @@ var Client = class {
    *   },
    * );
    * expect(result).toEqual({
-   *   wallet: jasmine.objectContaining({
+   *   wallet: expect.objectContaining({
    *     id: WALLETS.withEURFunds0.id,
    *     foreign: WALLETS.withEURFunds0.foreign,
    *     name: 'WT4',
-   *     metadata: {metadata_number: 2},
+   *     metadata: { metadata_number: 2 },
    *     type: WALLETS.withEURFunds0.type,
    *     status: 'disabled',
    *     default_allow_negative: false,