wapi-client 0.9.5 → 0.10.0

package/dist/client.d.ts

@@ -3,51 +3,62 @@ import { ClientHooks, ISocketId } from './api/base-client';
 import { AggregateQueryBuilder, UpdateQueryBuilder, ReverseQueryBuilder, QueryBuilder } from './lib/query-builder';
 import { StreamPromise } from './lib/stream-promise';
 import { StreamPromiseInput } from './lib/stream-promise-input';
-import { AggregateTransfersFnFields, AggregateTransfersFnGroupFields, AggregateTransfersFnMetadataFields, AggregateTransfersFnStringFields } from './fns/aggregate-transfers/aggregate-transfers';
-import { AggregateTransfersFnOutput, AggregateTransfersFnInput, AggregateTransfersFnOptions } from './fns/aggregate-transfers/aggregate-transfers.enums';
-import { CreateAccessTokenFnInput, CreateAccessTokenFnOptions, CreateAccessTokenFnOutput } from './fns/create-access-token/create-access-token.enums';
-import { CreateContractFnInput, CreateContractFnOptions, CreateContractFnOutput } from './fns/create-contract/create-contract.enums';
-import { CreateDepositFnInput, CreateDepositFnOptions, CreateDepositFnOutput } from './fns/create-deposit/create-deposit.enums';
-import { CreateExchangeFnInput, CreateExchangeFnOptions, CreateExchangeFnOutput } from './fns/create-exchange/create-exchange.enums';
-import { CreateTokenFnInput, CreateTokenFnOptions, CreateTokenFnOutput } from './fns/create-token/create-token.enums';
-import { CreateTransferGroupFnInput, CreateTransferGroupFnOptions, CreateTransferGroupFnOutput } from './fns/create-transfer-group/create-transfer-group.enums';
-import { CreateTransferFnInput, CreateTransferFnOptions, CreateTransferFnOutput } from './fns/create-transfer/create-transfer.enums';
-import { CreateTransfersFnInput, CreateTransfersFnOptions, CreateTransfersFnOutput } from './fns/create-transfers/create-transfers.enums';
-import { CreateWalletFnInput, CreateWalletFnOptions, CreateWalletFnOutput } from './fns/create-wallet/create-wallet.enums';
-import { CreateWithdrawalFnInput, CreateWithdrawalFnOptions, CreateWithdrawalFnOutput } from './fns/create-withdrawal/create-withdrawal.enums';
-import { FindBalancesFnFields, FindBalancesFnStringFields, FindBalancesFnMetadataFields, FindBalancesFnResultFields } from './fns/find-balances/find-balances';
-import { FindBalancesFnOptions, FindBalancesFnOutput, FindBalancesFnInput } from './fns/find-balances/find-balances.enums';
-import { FindTokensFnFields, FindTokensFnStringFields, FindTokensFnMetadataFields, FindTokensFnResultFields } from './fns/find-tokens/find-tokens';
-import { FindTokensFnOptions, FindTokensFnOutput, FindTokensFnInput } from './fns/find-tokens/find-tokens.enums';
-import { FindTransferGroupsFnFields, FindTransferGroupsFnStringFields, FindTransferGroupsFnMetadataFields, FindTransferGroupsFnResultFields } from './fns/find-transfer-groups/find-transfer-groups';
-import { FindTransferGroupsFnOptions, FindTransferGroupsFnOutput, FindTransferGroupsFnInput } from './fns/find-transfer-groups/find-transfer-groups.enums';
-import { FindTransfersFnFields, FindTransfersFnStringFields, FindTransfersFnMetadataFields, FindTransfersFnResultFields } from './fns/find-transfers/find-transfers';
-import { FindTransfersFnOptions, FindTransfersFnOutput, FindTransfersFnInput } from './fns/find-transfers/find-transfers.enums';
-import { FindWalletsFnFields, FindWalletsFnStringFields, FindWalletsFnMetadataFields, FindWalletsFnResultFields } from './fns/find-wallets/find-wallets';
-import { FindWalletsFnOptions, FindWalletsFnOutput, FindWalletsFnInput } from './fns/find-wallets/find-wallets.enums';
-import { GetBalanceHistoryFnInput, GetBalanceHistoryFnOptions, GetBalanceHistoryFnOutput } from './fns/get-balance-history/get-balance-history.enums';
-import { GetBalanceFnInput, GetBalanceFnOptions, GetBalanceFnOutput } from './fns/get-balance/get-balance.enums';
-import { GetFlagsFnInput, GetFlagsFnOptions, GetFlagsFnOutput } from './fns/get-flags/get-flags.enums';
-import { GetStatisticsFnInput, GetStatisticsFnOptions, GetStatisticsFnOutput } from './fns/get-statistics/get-statistics.enums';
-import { GetTokenFnInput, GetTokenFnOptions, GetTokenFnOutput } from './fns/get-token/get-token.enums';
-import { GetTransferGroupFnInput, GetTransferGroupFnOptions, GetTransferGroupFnOutput } from './fns/get-transfer-group/get-transfer-group.enums';
-import { GetTransferFnInput, GetTransferFnOptions, GetTransferFnOutput } from './fns/get-transfer/get-transfer.enums';
-import { GetWalletFnInput, GetWalletFnOptions, GetWalletFnOutput } from './fns/get-wallet/get-wallet.enums';
-import { HealthcheckFnInput, HealthcheckFnOptions, HealthcheckFnOutput } from './fns/healthcheck/healthcheck.enums';
-import { ImportDataFnOptions, ImportDataFnOutput, ImportDataFnStreamChunk, ImportDataFnInput } from './fns/import-data/import-data.enums';
-import { ReverseTransferGroupFnInput, ReverseTransferGroupFnOptions, ReverseTransferGroupFnOutput } from './fns/reverse-transfer-group/reverse-transfer-group.enums';
-import { ReverseTransferFnInput, ReverseTransferFnOptions, ReverseTransferFnOutput } from './fns/reverse-transfer/reverse-transfer.enums';
-import { ReverseTransfersFnFields, ReverseTransfersFnStringFields, ReverseTransfersFnMetadataFields } from './fns/reverse-transfers/reverse-transfers';
-import { ReverseTransfersFnModifications, ReverseTransfersFnOutput, ReverseTransfersFnInput, ReverseTransfersFnOptions } from './fns/reverse-transfers/reverse-transfers.enums';
-import { SetFlagsFnInput, SetFlagsFnOptions, SetFlagsFnOutput } from './fns/set-flags/set-flags.enums';
-import { UpdateTokenFnInput, UpdateTokenFnOptions, UpdateTokenFnOutput } from './fns/update-token/update-token.enums';
-import { UpdateTransferGroupFnInput, UpdateTransferGroupFnOptions, UpdateTransferGroupFnOutput } from './fns/update-transfer-group/update-transfer-group.enums';
-import { UpdateTransferGroupsFnFields, UpdateTransferGroupsFnStringFields, UpdateTransferGroupsFnMetadataFields, UpdateTransferGroupsFnResultFields } from './fns/update-transfer-groups/update-transfer-groups';
-import { UpdateTransferGroupsFnUpdateFields, UpdateTransferGroupsFnOutput, UpdateTransferGroupsFnInput, UpdateTransferGroupsFnOptions } from './fns/update-transfer-groups/update-transfer-groups.enums';
-import { UpdateTransferFnInput, UpdateTransferFnOptions, UpdateTransferFnOutput } from './fns/update-transfer/update-transfer.enums';
-import { UpdateTransfersFnFields, UpdateTransfersFnStringFields, UpdateTransfersFnMetadataFields, UpdateTransfersFnResultFields } from './fns/update-transfers/update-transfers';
-import { UpdateTransfersFnUpdateFields, UpdateTransfersFnOutput, UpdateTransfersFnInput, UpdateTransfersFnOptions } from './fns/update-transfers/update-transfers.enums';
-import { UpdateWalletFnInput, UpdateWalletFnOptions, UpdateWalletFnOutput } from './fns/update-wallet/update-wallet.enums';
+import { AggregateTransfersFnInput, AggregateTransfersFnOutput, AggregateTransfersFnOptions } from './fns/aggregate-transfers/aggregate-transfers.enums';
+import { AggregateTransfersFnFields, AggregateTransfersFnMetadataFields, AggregateTransfersFnStringFields, AggregateTransfersFnGroupFields } from './fns/aggregate-transfers/aggregate-transfers';
+import { CreateAccessTokenFnInput, CreateAccessTokenFnOutput, CreateAccessTokenFnOptions } from './fns/create-access-token/create-access-token.enums';
+import { CreateContractFnInput, CreateContractFnOutput, CreateContractFnOptions } from './fns/create-contract/create-contract.enums';
+import { CreateDepositFnInput, CreateDepositFnOutput, CreateDepositFnOptions } from './fns/create-deposit/create-deposit.enums';
+import { CreateExchangeFnInput, CreateExchangeFnOutput, CreateExchangeFnOptions } from './fns/create-exchange/create-exchange.enums';
+import { CreateTokenFnInput, CreateTokenFnOutput, CreateTokenFnOptions } from './fns/create-token/create-token.enums';
+import { CreateTransferFnInput, CreateTransferFnOutput, CreateTransferFnOptions } from './fns/create-transfer/create-transfer.enums';
+import { CreateTransferGroupFnInput, CreateTransferGroupFnOutput, CreateTransferGroupFnOptions } from './fns/create-transfer-group/create-transfer-group.enums';
+import { CreateTransfersFnInput, CreateTransfersFnOutput, CreateTransfersFnOptions } from './fns/create-transfers/create-transfers.enums';
+import { CreateWalletFnInput, CreateWalletFnOutput, CreateWalletFnOptions } from './fns/create-wallet/create-wallet.enums';
+import { CreateWithdrawalFnInput, CreateWithdrawalFnOutput, CreateWithdrawalFnOptions } from './fns/create-withdrawal/create-withdrawal.enums';
+import { ExportBalanceHistoryFnInput, ExportBalanceHistoryFnOutput, ExportBalanceHistoryFnOptions } from './fns/export-balance-history/export-balance-history.enums';
+import { ExportTokensFnInput, ExportTokensFnOutput, ExportTokensFnOptions } from './fns/export-tokens/export-tokens.enums';
+import { ExportTokensFnFields, ExportTokensFnMetadataFields, ExportTokensFnStringFields, ExportTokensFnResultFields } from './fns/export-tokens/export-tokens';
+import { ExportTransferGroupsFnInput, ExportTransferGroupsFnOutput, ExportTransferGroupsFnOptions } from './fns/export-transfer-groups/export-transfer-groups.enums';
+import { ExportTransferGroupsFnFields, ExportTransferGroupsFnMetadataFields, ExportTransferGroupsFnStringFields, ExportTransferGroupsFnResultFields } from './fns/export-transfer-groups/export-transfer-groups';
+import { ExportTransfersFnInput, ExportTransfersFnOutput, ExportTransfersFnOptions } from './fns/export-transfers/export-transfers.enums';
+import { ExportTransfersFnFields, ExportTransfersFnMetadataFields, ExportTransfersFnStringFields, ExportTransfersFnResultFields } from './fns/export-transfers/export-transfers';
+import { ExportWalletsFnInput, ExportWalletsFnOutput, ExportWalletsFnOptions } from './fns/export-wallets/export-wallets.enums';
+import { ExportWalletsFnFields, ExportWalletsFnMetadataFields, ExportWalletsFnStringFields, ExportWalletsFnResultFields } from './fns/export-wallets/export-wallets';
+import { FindBalancesFnInput, FindBalancesFnOutput, FindBalancesFnOptions } from './fns/find-balances/find-balances.enums';
+import { FindBalancesFnFields, FindBalancesFnMetadataFields, FindBalancesFnStringFields, FindBalancesFnResultFields } from './fns/find-balances/find-balances';
+import { FindTokensFnInput, FindTokensFnOutput, FindTokensFnOptions } from './fns/find-tokens/find-tokens.enums';
+import { FindTokensFnFields, FindTokensFnMetadataFields, FindTokensFnStringFields, FindTokensFnResultFields } from './fns/find-tokens/find-tokens';
+import { FindTransferGroupsFnInput, FindTransferGroupsFnOutput, FindTransferGroupsFnOptions } from './fns/find-transfer-groups/find-transfer-groups.enums';
+import { FindTransferGroupsFnFields, FindTransferGroupsFnMetadataFields, FindTransferGroupsFnStringFields, FindTransferGroupsFnResultFields } from './fns/find-transfer-groups/find-transfer-groups';
+import { FindTransfersFnInput, FindTransfersFnOutput, FindTransfersFnOptions } from './fns/find-transfers/find-transfers.enums';
+import { FindTransfersFnFields, FindTransfersFnMetadataFields, FindTransfersFnStringFields, FindTransfersFnResultFields } from './fns/find-transfers/find-transfers';
+import { FindWalletsFnInput, FindWalletsFnOutput, FindWalletsFnOptions } from './fns/find-wallets/find-wallets.enums';
+import { FindWalletsFnFields, FindWalletsFnMetadataFields, FindWalletsFnStringFields, FindWalletsFnResultFields } from './fns/find-wallets/find-wallets';
+import { GetBalanceFnInput, GetBalanceFnOutput, GetBalanceFnOptions } from './fns/get-balance/get-balance.enums';
+import { GetBalanceHistoryFnInput, GetBalanceHistoryFnOutput, GetBalanceHistoryFnOptions } from './fns/get-balance-history/get-balance-history.enums';
+import { GetExportFnInput, GetExportFnOutput, GetExportFnOptions } from './fns/get-export/get-export.enums';
+import { GetFlagsFnInput, GetFlagsFnOutput, GetFlagsFnOptions } from './fns/get-flags/get-flags.enums';
+import { GetStatisticsFnInput, GetStatisticsFnOutput, GetStatisticsFnOptions } from './fns/get-statistics/get-statistics.enums';
+import { GetTokenFnInput, GetTokenFnOutput, GetTokenFnOptions } from './fns/get-token/get-token.enums';
+import { GetTransferFnInput, GetTransferFnOutput, GetTransferFnOptions } from './fns/get-transfer/get-transfer.enums';
+import { GetTransferGroupFnInput, GetTransferGroupFnOutput, GetTransferGroupFnOptions } from './fns/get-transfer-group/get-transfer-group.enums';
+import { GetWalletFnInput, GetWalletFnOutput, GetWalletFnOptions } from './fns/get-wallet/get-wallet.enums';
+import { HealthcheckFnInput, HealthcheckFnOutput, HealthcheckFnOptions } from './fns/healthcheck/healthcheck.enums';
+import { ImportDataFnInput, ImportDataFnOutput, ImportDataFnOptions, ImportDataFnStreamChunk } from './fns/import-data/import-data.enums';
+import { ListExportsFnInput, ListExportsFnOutput, ListExportsFnOptions } from './fns/list-exports/list-exports.enums';
+import { ReverseTransferFnInput, ReverseTransferFnOutput, ReverseTransferFnOptions } from './fns/reverse-transfer/reverse-transfer.enums';
+import { ReverseTransferGroupFnInput, ReverseTransferGroupFnOutput, ReverseTransferGroupFnOptions } from './fns/reverse-transfer-group/reverse-transfer-group.enums';
+import { ReverseTransfersFnInput, ReverseTransfersFnOutput, ReverseTransfersFnOptions, ReverseTransfersFnModifications } from './fns/reverse-transfers/reverse-transfers.enums';
+import { ReverseTransfersFnFields, ReverseTransfersFnMetadataFields, ReverseTransfersFnStringFields } from './fns/reverse-transfers/reverse-transfers';
+import { SetFlagsFnInput, SetFlagsFnOutput, SetFlagsFnOptions } from './fns/set-flags/set-flags.enums';
+import { UpdateTokenFnInput, UpdateTokenFnOutput, UpdateTokenFnOptions } from './fns/update-token/update-token.enums';
+import { UpdateTransferFnInput, UpdateTransferFnOutput, UpdateTransferFnOptions } from './fns/update-transfer/update-transfer.enums';
+import { UpdateTransferGroupFnInput, UpdateTransferGroupFnOutput, UpdateTransferGroupFnOptions } from './fns/update-transfer-group/update-transfer-group.enums';
+import { UpdateTransferGroupsFnInput, UpdateTransferGroupsFnOutput, UpdateTransferGroupsFnOptions, UpdateTransferGroupsFnUpdateFields } from './fns/update-transfer-groups/update-transfer-groups.enums';
+import { UpdateTransferGroupsFnFields, UpdateTransferGroupsFnMetadataFields, UpdateTransferGroupsFnStringFields, UpdateTransferGroupsFnResultFields } from './fns/update-transfer-groups/update-transfer-groups';
+import { UpdateTransfersFnInput, UpdateTransfersFnOutput, UpdateTransfersFnOptions, UpdateTransfersFnUpdateFields } from './fns/update-transfers/update-transfers.enums';
+import { UpdateTransfersFnFields, UpdateTransfersFnMetadataFields, UpdateTransfersFnStringFields, UpdateTransfersFnResultFields } from './fns/update-transfers/update-transfers';
+import { UpdateWalletFnInput, UpdateWalletFnOutput, UpdateWalletFnOptions } from './fns/update-wallet/update-wallet.enums';
 export interface ClientConfig {
     token?: number | string;
     hooks?: ClientHooks;
@@ -133,7 +144,8 @@ export declare class Client {
      *
      * ```javascript
      *
-     * const result = await wapiClient.aggregateTransfers()
+     * const result = await wapiClient
+     *   .aggregateTransfers()
      *   .where({
      *     type: 'deposit',
      *     from_wallet: 'EUR',
@@ -142,16 +154,13 @@ export declare class Client {
      *   .whereMetadata('example', 'test')
      *   .sum('to.amount as amount')
      *   .count()
-     *   .groupBy(
-     *     'metadata.even as type',
-     *     'hour',
-     *     )
+     *   .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'
-     *     }
+     *       end_time: '2021-07-31 13:00:00',
+     *     },
      *   });
      *
      * expect(result).toEqual({
@@ -231,7 +240,7 @@ export declare class Client {
      *       token_foreign: 'EUR',
      *     },
      *     expiresIn: 60,
-     *   }
+     *   },
      * });
      *
      * ```
@@ -279,25 +288,28 @@ export declare class Client {
      *
      * ```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',
@@ -308,7 +320,7 @@ export declare class Client {
      *     status: 'finished',
      *     // ... other fields
      *   }),
-     *   to_balance: jasmine.objectContaining({
+     *   to_balance: expect.objectContaining({
      *     token_foreign: 'ForeignForToken',
      *     wallet_foreign: 'ForeignForWallet',
      *     pending_amount: 0,
@@ -333,32 +345,35 @@ export declare class Client {
      *
      * ```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,
@@ -369,7 +384,7 @@ export declare class Client {
      *       },
      *       identifier: 'exchange1',
      *     }),
-     *     jasmine.objectContaining({
+     *     expect.objectContaining({
      *       status: 'finished',
      *       amount: 20,
      *       to_wallet_id: WALLETS.withEURFunds0.id,
@@ -415,14 +430,14 @@ export declare class Client {
      * );
      *
      * 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',
@@ -445,26 +460,29 @@ export declare class Client {
      *
      * ```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,
@@ -481,12 +499,12 @@ export declare class Client {
      *
      * ```
      *
-     * @param {CreateTransferFnInput} [input]
+     * @param {CreateTransferFnInput} input
      * @param {CreateTransferFnOptions} [options]
      * @returns {StreamPromise<CreateTransferFnOutput>}
      *
      */
-    createTransfer(input?: CreateTransferFnInput, options?: CreateTransferFnOptions): StreamPromise<CreateTransferFnOutput>;
+    createTransfer(input: CreateTransferFnInput, options?: CreateTransferFnOptions): StreamPromise<CreateTransferFnOutput>;
     /**
      *
      * Create a TransferGroup entity to group transfers into a logical or status locked group.
@@ -496,69 +514,75 @@ export declare class Client {
      *
      * ```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',
+     *       }),
+     *     ],
+     *   }),
+     * );
      *
      *
      * ```
@@ -576,91 +600,100 @@ export declare class Client {
      *
      * ```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,
+     *       }),
+     *     ],
+     *   }),
+     * );
      *
      *
      * ```
@@ -677,20 +710,23 @@ export declare class Client {
      *
      * ```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: {
@@ -716,25 +752,28 @@ export declare class Client {
      *
      * ```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',
@@ -745,7 +784,7 @@ export declare class Client {
      *     status: 'finished',
      *     // ... other fields
      *   }),
-     *   from_balance: jasmine.objectContaining({
+     *   from_balance: expect.objectContaining({
      *     token_foreign: 'ForeignForToken',
      *     wallet_foreign: 'ForeignForWallet',
      *     pending_amount: 0,
@@ -763,6 +802,150 @@ export declare class Client {
      *
      */
     createWithdrawal(input: CreateWithdrawalFnInput, options?: CreateWithdrawalFnOptions): StreamPromise<CreateWithdrawalFnOutput>;
+    /**
+     *
+     *
+     *
+     * @param {ExportBalanceHistoryFnInput} input
+     * @param {ExportBalanceHistoryFnOptions} [options]
+     * @returns {StreamPromise<ExportBalanceHistoryFnOutput>}
+     *
+     */
+    exportBalanceHistory(input: ExportBalanceHistoryFnInput, options?: ExportBalanceHistoryFnOptions): StreamPromise<ExportBalanceHistoryFnOutput>;
+    /**
+     *
+     * Search for Tokens using either a simple filter or queryBuilder
+     *
+     *
+     * ```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,
+     *   });
+     *
+     * ```
+     *
+     * @param {ExportTokensFnInput} [input]
+     * @param {ExportTokensFnOptions} [options]
+     * @returns {StreamPromise<ExportTokensFnOutput>}
+     *
+     */
+    exportTokens(): QueryBuilder<ExportTokensFnFields, ExportTokensFnStringFields, ExportTokensFnMetadataFields, ExportTokensFnResultFields, ExportTokensFnOptions, ExportTokensFnOutput>;
+    exportTokens(input: ExportTokensFnInput, options?: ExportTokensFnOptions): StreamPromise<ExportTokensFnOutput>;
+    /**
+     *
+     * Search for TransferGroups using either a simple filter or queryBuilder
+     *
+     *
+     * ```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,
+     *   });
+     *
+     * ```
+     *
+     * @param {ExportTransferGroupsFnInput} [input]
+     * @param {ExportTransferGroupsFnOptions} [options]
+     * @returns {StreamPromise<ExportTransferGroupsFnOutput>}
+     *
+     */
+    exportTransferGroups(): QueryBuilder<ExportTransferGroupsFnFields, ExportTransferGroupsFnStringFields, ExportTransferGroupsFnMetadataFields, ExportTransferGroupsFnResultFields, ExportTransferGroupsFnOptions, ExportTransferGroupsFnOutput>;
+    exportTransferGroups(input: ExportTransferGroupsFnInput, options?: ExportTransferGroupsFnOptions): StreamPromise<ExportTransferGroupsFnOutput>;
+    /**
+     *
+     * Search for Transfers using either a simple filter or queryBuilder
+     *
+     *
+     * ```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',
+     *   });
+     *
+     * ```
+     *
+     * @param {ExportTransfersFnInput} [input]
+     * @param {ExportTransfersFnOptions} [options]
+     * @returns {StreamPromise<ExportTransfersFnOutput>}
+     *
+     */
+    exportTransfers(): QueryBuilder<ExportTransfersFnFields, ExportTransfersFnStringFields, ExportTransfersFnMetadataFields, ExportTransfersFnResultFields, ExportTransfersFnOptions, ExportTransfersFnOutput>;
+    exportTransfers(input: ExportTransfersFnInput, options?: ExportTransfersFnOptions): StreamPromise<ExportTransfersFnOutput>;
+    /**
+     *
+     * Search for Wallets using either a simple filter or queryBuilder
+     *
+     *
+     * ```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',
+     *   });
+     *
+     * ```
+     *
+     * @param {ExportWalletsFnInput} [input]
+     * @param {ExportWalletsFnOptions} [options]
+     * @returns {StreamPromise<ExportWalletsFnOutput>}
+     *
+     */
+    exportWallets(): QueryBuilder<ExportWalletsFnFields, ExportWalletsFnStringFields, ExportWalletsFnMetadataFields, ExportWalletsFnResultFields, ExportWalletsFnOptions, ExportWalletsFnOutput>;
+    exportWallets(input: ExportWalletsFnInput, options?: ExportWalletsFnOptions): StreamPromise<ExportWalletsFnOutput>;
     /**
      *
      * Search for Balances using either a simple filter or queryBuilder
@@ -770,7 +953,8 @@ export declare class Client {
      *
      * ```javascript
      *
-     * const result = await wapiClient.findBalances()
+     * const result = await wapiClient
+     *   .findBalances()
      *   .where({
      *     wallet: WALLETS.validId0,
      *   })
@@ -779,8 +963,9 @@ export declare class Client {
      *     wallet: WALLETS.validId1,
      *     token: 'USD',
      *   })
-     *   .orWhere(builder => {
-     *     builder.where('updated_at', '<', '2020-01-01')
+     *   .orWhere((builder) => {
+     *     builder
+     *       .where('updated_at', '<', '2020-01-01')
      *       .where('amount', '<', -1000000);
      *   })
      *   .limit(5)
@@ -807,7 +992,8 @@ export declare class Client {
      *
      * ```javascript
      *
-     * const result = await wapiClient.findTokens()
+     * const result = await wapiClient
+     *   .findTokens()
      *   .where({
      *     metadata: {
      *       even: true,
@@ -819,10 +1005,11 @@ export declare class Client {
      *   })
      *   .limit(5)
      *   .offset(0)
-     *   .orderBy(['foreign', {column: 'id', order: 'desc'}])
+     *   .orderBy(['foreign', { column: 'id', order: 'desc' }])
      *   .options({
      *     tracking_id: 'hello',
      *     return_metadata_total: true,
+     *     include_balance: true,
      *   });
      *
      * ```
@@ -841,7 +1028,8 @@ export declare class Client {
      *
      * ```javascript
      *
-     * const result = await wapiClient.findTransferGroups()
+     * const result = await wapiClient
+     *   .findTransferGroups()
      *   .where({
      *     metadata: {
      *       even: true,
@@ -851,12 +1039,13 @@ export declare class Client {
      *   .orWhere({
      *     identifier: 'reverser-example',
      *   })
-     *   .orWhere(builder => {
-     *     builder.where({
-     *       metadata: {
-     *         kak: true,
-     *       },
-     *     })
+     *   .orWhere((builder) => {
+     *     builder
+     *       .where({
+     *         metadata: {
+     *           kak: true,
+     *         },
+     *       })
      *       .where('created_at', '>', '2020-01-01');
      *   })
      *   .limit(5)
@@ -866,6 +1055,7 @@ export declare class Client {
      *   .options({
      *     tracking_id: 'hello',
      *     return_metadata_total: true,
+     *     return_transfers_count: true,
      *   });
      *
      * ```
@@ -884,20 +1074,20 @@ export declare class Client {
      *
      * ```javascript
      *
-     * const result = await wapiClient.findTransfers()
+     * const result = await wapiClient
+     *   .findTransfers()
      *   .where({
      *     metadata: {
      *       example: true,
      *     },
      *   })
      *   .where('id', '>', 1)
-     *   .where(builder => {
-     *     builder.where('status', 'finished')
-     *       .orWhere('type', 'deposit');
+     *   .where((builder) => {
+     *     builder.where('status', 'finished').orWhere('type', 'deposit');
      *   })
      *   .limit(5)
      *   .offset(0)
-     *   .orderBy(['token_id', {column: 'id', order: 'desc'}])
+     *   .orderBy(['token_id', { column: 'id', order: 'desc' }])
      *   .select('id', 'type', 'from_wallet_foreign', 'to_wallet_foreign')
      *   .options({
      *     tracking_id: 'hello',
@@ -919,21 +1109,20 @@ export declare class Client {
      *
      * ```javascript
      *
-     * const result = await wapiClient.findWallets()
+     * const result = await wapiClient
+     *   .findWallets()
      *   .where({
      *     metadata: {
      *       general: true,
      *     },
      *   })
      *   .where('id', '>', 1)
-     *   .where(builder => {
-     *     builder
-     *       .whereMetadata('tost', 10)
-     *       .orWhereMetadata('test', 1);
+     *   .where((builder) => {
+     *     builder.whereMetadata('tost', 10).orWhereMetadata('test', 1);
      *   })
      *   .limit(5)
      *   .offset(0)
-     *   .orderBy(['status', {column: 'id', order: 'desc'}])
+     *   .orderBy(['status', { column: 'id', order: 'desc' }])
      *   .select('id')
      *   .options({
      *     tracking_id: 'hello',
@@ -954,20 +1143,23 @@ export declare class Client {
      *
      * ```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,
@@ -995,66 +1187,72 @@ export declare class Client {
      * ```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: [
      *     {
@@ -1090,6 +1288,30 @@ export declare class Client {
      *
      */
     getBalanceHistory(input: GetBalanceHistoryFnInput, options?: GetBalanceHistoryFnOptions): StreamPromise<GetBalanceHistoryFnOutput>;
+    /**
+     *
+     * 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: GetExportFnInput, options?: GetExportFnOptions): StreamPromise<GetExportFnOutput>;
     /**
      *
      * Retrieve the current state of configurable Flags for your WAPI instance
@@ -1116,29 +1338,38 @@ export declare class Client {
      *
      * ```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')}`,
      *     },
      *   ],
@@ -1158,20 +1389,27 @@ export declare class Client {
      *
      * ```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,
      *   }),
      * });
      *
@@ -1189,14 +1427,17 @@ export declare class Client {
      *
      * ```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',
      *     // ...
      *   }),
@@ -1216,16 +1457,19 @@ export declare class Client {
      *
      * ```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',
@@ -1250,17 +1494,20 @@ export declare class Client {
      *
      * ```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,
      *   }),
      * });
@@ -1275,24 +1522,19 @@ export declare class Client {
     getWallet(input: GetWalletFnInput, options?: GetWalletFnOptions): StreamPromise<GetWalletFnOutput>;
     /**
      *
-     * 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>}
      *
@@ -1304,11 +1546,13 @@ export declare class Client {
      * ```javascript
      *
      * const result = await wapiClient.importData().input(async (stream) => {
-     *   const fileStream = createReadStream(join(__dirname, '../lib/short-import.txt'));
+     *   const fileStream = createReadStream(
+     *     join(__dirname, '../lib/short-import.txt'),
+     *   );
      *
      *   const rl = createInterface({
      *     input: fileStream,
-     *     crlfDelay: Infinity
+     *     crlfDelay: Infinity,
      *   });
      *   for await (const line of rl) {
      *     // Each line in input.txt will be successively available here as `line`.
@@ -1330,6 +1574,28 @@ export declare class Client {
      */
     importData(options?: ImportDataFnOptions): StreamPromiseInput<ImportDataFnOutput, ImportDataFnStreamChunk>;
     importData(input: ImportDataFnInput, options?: ImportDataFnOptions): StreamPromise<ImportDataFnOutput>;
+    /**
+     *
+     * 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?: ListExportsFnInput, options?: ListExportsFnOptions): StreamPromise<ListExportsFnOutput>;
     /**
      *
      * Reverse a transfer of value between two wallets
@@ -1337,26 +1603,29 @@ export declare class Client {
      *
      * ```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',
@@ -1373,12 +1642,12 @@ export declare class Client {
      *     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,
      *     // ...
@@ -1401,26 +1670,29 @@ export declare class Client {
      * ```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: {
@@ -1430,7 +1702,7 @@ export declare class Client {
      *     transfer_status: 'finished',
      *   }),
      *   transfers: [
-     *     jasmine.objectContaining({
+     *     expect.objectContaining({
      *       from_wallet_foreign: 'myWallet2',
      *       to_wallet_foreign: 'myWallet1',
      *       amount: 8,
@@ -1438,7 +1710,7 @@ export declare class Client {
      *       status: 'finished',
      *       token_foreign: 'EUR',
      *     }),
-     *     jasmine.objectContaining({
+     *     expect.objectContaining({
      *       from_wallet_foreign: 'myWallet1',
      *       to_wallet_foreign: 'EUR',
      *       amount: 10,
@@ -1463,35 +1735,39 @@ export declare class Client {
      * ```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('*'),
+     *   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'
+     *     example: 'test',
      *   },
      * });
      *
@@ -1499,14 +1775,26 @@ export declare class Client {
      * 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[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);
+     * 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,
+     * );
      *
      * ```
      *
@@ -1523,12 +1811,15 @@ export declare class Client {
      *
      * ```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,
@@ -1566,7 +1857,7 @@ export declare class Client {
      *   },
      * );
      * expect(result).toEqual({
-     *   token: jasmine.objectContaining({
+     *   token: expect.objectContaining({
      *     belongs_to: TOKENS.EUR.belongs_to,
      *     divisor: TOKENS.EUR.divisor,
      *     id: TOKENS.EUR.id,
@@ -1596,23 +1887,26 @@ export declare class Client {
      *
      * ```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',
@@ -1626,16 +1920,16 @@ export declare class Client {
      *       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,
@@ -1659,24 +1953,33 @@ export declare class Client {
      *
      * ```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',
@@ -1684,7 +1987,7 @@ export declare class Client {
      *       to_wallet_foreign: 'myWallet1',
      *       token_foreign: 'EUR',
      *     }),
-     *     jasmine.objectContaining({
+     *     expect.objectContaining({
      *       identifier: 'transferB',
      *       type: 'transfer',
      *       status: 'finished',
@@ -1709,7 +2012,8 @@ export declare class Client {
      *
      * ```javascript
      *
-     * const result = await wapiClient.updateTransferGroups()
+     * const result = await wapiClient
+     *   .updateTransferGroups()
      *   .where({
      *     status: 'open',
      *   })
@@ -1781,11 +2085,11 @@ export declare class Client {
      *   },
      * );
      * 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,