wapi-client 0.4.3 → 0.6.1

package/dist/client.d.ts

@@ -1,1714 +1,1740 @@
-import { WapiConnectionOptions, WsClient } from './api';
-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 { AggregateTransfersFnInput, AggregateTransfersFnOutput, AggregateTransfersFnOptions, AggregateTransfersFnFields, AggregateTransfersFnMetadataFields, AggregateTransfersFnStringFields, AggregateTransfersFnGroupFields, CreateContractFnInput, CreateContractFnOutput, CreateContractFnOptions, CreateDepositFnInput, CreateDepositFnOutput, CreateDepositFnOptions, CreateExchangeFnInput, CreateExchangeFnOutput, CreateExchangeFnOptions, CreateTokenFnInput, CreateTokenFnOutput, CreateTokenFnOptions, CreateTransferFnInput, CreateTransferFnOutput, CreateTransferFnOptions, CreateTransferGroupFnInput, CreateTransferGroupFnOutput, CreateTransferGroupFnOptions, CreateTransfersFnInput, CreateTransfersFnOutput, CreateTransfersFnOptions, CreateWalletFnInput, CreateWalletFnOutput, CreateWalletFnOptions, CreateWithdrawalFnInput, CreateWithdrawalFnOutput, CreateWithdrawalFnOptions, FindBalancesFnInput, FindBalancesFnOutput, FindBalancesFnOptions, FindBalancesFnFields, FindBalancesFnMetadataFields, FindBalancesFnStringFields, FindBalancesFnResultFields, FindTokensFnInput, FindTokensFnOutput, FindTokensFnOptions, FindTokensFnFields, FindTokensFnMetadataFields, FindTokensFnStringFields, FindTokensFnResultFields, FindTransferGroupsFnInput, FindTransferGroupsFnOutput, FindTransferGroupsFnOptions, FindTransferGroupsFnFields, FindTransferGroupsFnMetadataFields, FindTransferGroupsFnStringFields, FindTransferGroupsFnResultFields, FindTransfersFnInput, FindTransfersFnOutput, FindTransfersFnOptions, FindTransfersFnFields, FindTransfersFnMetadataFields, FindTransfersFnStringFields, FindTransfersFnResultFields, FindWalletsFnInput, FindWalletsFnOutput, FindWalletsFnOptions, FindWalletsFnFields, FindWalletsFnMetadataFields, FindWalletsFnStringFields, FindWalletsFnResultFields, GetBalanceFnInput, GetBalanceFnOutput, GetBalanceFnOptions, GetBalanceHistoryFnInput, GetBalanceHistoryFnOutput, GetBalanceHistoryFnOptions, GetFlagsFnInput, GetFlagsFnOutput, GetFlagsFnOptions, GetStatisticsFnInput, GetStatisticsFnOutput, GetStatisticsFnOptions, GetTokenFnInput, GetTokenFnOutput, GetTokenFnOptions, GetTransferFnInput, GetTransferFnOutput, GetTransferFnOptions, GetTransferGroupFnInput, GetTransferGroupFnOutput, GetTransferGroupFnOptions, GetWalletFnInput, GetWalletFnOutput, GetWalletFnOptions, ImportDataFnInput, ImportDataFnOutput, ImportDataFnOptions, ImportDataFnStreamChunk, ReverseTransferFnInput, ReverseTransferFnOutput, ReverseTransferFnOptions, ReverseTransferGroupFnInput, ReverseTransferGroupFnOutput, ReverseTransferGroupFnOptions, ReverseTransfersFnInput, ReverseTransfersFnOutput, ReverseTransfersFnOptions, ReverseTransfersFnFields, ReverseTransfersFnMetadataFields, ReverseTransfersFnStringFields, ReverseTransfersFnModifications, SetFlagsFnInput, SetFlagsFnOutput, SetFlagsFnOptions, UpdateTokenFnInput, UpdateTokenFnOutput, UpdateTokenFnOptions, UpdateTransferFnInput, UpdateTransferFnOutput, UpdateTransferFnOptions, UpdateTransferGroupFnInput, UpdateTransferGroupFnOutput, UpdateTransferGroupFnOptions, UpdateTransferGroupsFnInput, UpdateTransferGroupsFnOutput, UpdateTransferGroupsFnOptions, UpdateTransferGroupsFnFields, UpdateTransferGroupsFnMetadataFields, UpdateTransferGroupsFnStringFields, UpdateTransferGroupsFnResultFields, UpdateTransferGroupsFnUpdateFields, UpdateTransfersFnInput, UpdateTransfersFnOutput, UpdateTransfersFnOptions, UpdateTransfersFnFields, UpdateTransfersFnMetadataFields, UpdateTransfersFnStringFields, UpdateTransfersFnResultFields, UpdateTransfersFnUpdateFields, UpdateWalletFnInput, UpdateWalletFnOutput, UpdateWalletFnOptions } from './fns';
-export interface ClientConfig {
-    token?: number | string;
-    hooks?: ClientHooks;
-}
-export declare class Client {
-    /**
-     * The BaseClient in use for communication with WAPI Server, manages the actual networking
-     */
-    api: WsClient;
-    /**
-     * Promise resolving to ID upon connection opening
-     */
-    $connect: Promise<ISocketId>;
-    private config;
-    /**
-     * @internal
-     */
-    constructor(_apiClient: WsClient, initialConf?: ClientConfig);
-    /**
-     * Close connection to WAPI instance
-     *
-     * ```javascript
-     *
-     * await wapiClient.close();
-     *
-     * ```
-     */
-    close(): Promise<void>;
-    /**
-     * Returns WAPI client verion
-     *
-     * ```javascript
-     *
-     * wapiClient.version();
-     *
-     * ```
-     */
-    version(): string;
-    /**
-     * Set a hook function
-     *
-     * ```javascript
-     *
-     * wapiClient.setHook('disconnect', () => {
-     *   console.log('disconnected');
-     * });
-     *
-     * ```
-     * @param {ClientHooks} hookName
-     * @param value
-     */
-    setHook(hookName: keyof ClientHooks, value: (input?: unknown) => boolean | void): this;
-    /**
-     * Overwrite client configuration (default token, hooks)
-     *
-     *
-     * ```javascript
-     *
-     * wapiClient.configure({
-     *  token: 'EURO',
-     *  hooks: {
-     *    disconnect: () => {}
-     *  },
-     * });
-     *
-     * ```
-     * @param {ClientConfig} newConf
-     */
-    configure(newConf: Partial<ClientConfig>): this;
-    /**
-     * Get current config key value (token)
-     * ```javascript
-     *
-     * const token = wapiClient.getConfig('token');
-     *
-     * ```
-     */
-    getConfig(key: 'token'): number | string | undefined;
-    /**
-     *
-     * Aggregate Transfers using either a simple filter or queryBuilder
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.aggregateTransfers()
-     *   .where({
-     *     type: 'deposit',
-     *     from_wallet: 'EUR',
-     *     to_wallet: 'house',
-     *   })
-     *   .whereMetadata('example', 'test')
-     *   .sum('to.amount as amount')
-     *   .count()
-     *   .groupBy(
-     *     'metadata.even as type',
-     *     'hour',
-     *     )
-     *   .options({
-     *     tracking_id: 'hello',
-     *     return_all_intervals: {
-     *       start_time: '2021-07-31 11:00:00',
-     *       end_time: '2021-07-31 13:00:00'
-     *     }
-     *   });
-     *
-     * expect(result).toEqual({
-     *   rows: [
-     *     {
-     *       amount: 25,
-     *       count: 5,
-     *       type: 'even',
-     *       hour: '2021-07-31 12',
-     *     },
-     *     {
-     *       amount: 30,
-     *       count: 5,
-     *       type: 'odd',
-     *       hour: '2021-07-31 12',
-     *     },
-     *     {
-     *       amount: null,
-     *       count: 0,
-     *       type: null,
-     *       hour: '2021-07-31 11',
-     *     },
-     *     {
-     *       amount: null,
-     *       count: 0,
-     *       type: null,
-     *       hour: '2021-07-31 13',
-     *     },
-     *   ],
-     *   metadata: {
-     *     aggregators: [
-     *       {
-     *         function: 'sum',
-     *         field: 'to.amount',
-     *         alias: 'amount',
-     *       },
-     *       {
-     *         function: 'count',
-     *         alias: 'count',
-     *       },
-     *     ],
-     *     groups: [
-     *       {
-     *         type: 'metadata_field',
-     *         field: 'even',
-     *         alias: 'type',
-     *       },
-     *       {
-     *         alias: 'hour',
-     *         field: 'hour',
-     *         type: 'period',
-     *       },
-     *     ],
-     *   },
-     * });
-     *
-     * ```
-     *
-     * @param {AggregateTransfersFnInput} [input]
-     * @param {AggregateTransfersFnOptions} [options]
-     * @returns {StreamPromise<AggregateTransfersFnOutput>}
-     *
-     */
-    aggregateTransfers(): AggregateQueryBuilder<AggregateTransfersFnFields, AggregateTransfersFnStringFields, AggregateTransfersFnMetadataFields, AggregateTransfersFnGroupFields, AggregateTransfersFnOutput>;
-    aggregateTransfers(input: AggregateTransfersFnInput, options?: AggregateTransfersFnOptions): StreamPromise<AggregateTransfersFnOutput>;
-    /**
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createContract({
-     *   foreign: 'MYContract',
-     *   metadata: {
-     *     cool: true,
-     *   },
-     *   value_token: 'EUR',
-     *   value_amount: 100,
-     *   owner: 'oppo',
-     *   buyer: {
-     *     wallet: WALLETS.withEURFunds0.foreign,
-     *     metadata: {
-     *       buying: true,
-     *     },
-     *     amount: 101,
-     *     token: 'EUR',
-     *   },
-     * });
-     *
-     * ```
-     *
-     * @param {CreateContractFnInput} input
-     * @param {CreateContractFnOptions} [options]
-     * @returns {StreamPromise<CreateContractFnOutput>}
-     *
-     */
-    createContract(input: CreateContractFnInput, options?: CreateContractFnOptions): StreamPromise<CreateContractFnOutput>;
-    /**
-     *
-     * Create a deposit transaction into a wallet, by issuing new tokens to the system.
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createDeposit({
-     *   identifier: 'mycustomId',
-     *   token: 'ForeignForToken',
-     *   wallet: 'ForeignForWallet',
-     *   amount: 10.01,
-     *   metadata: {
-     *     customJsonBlob: true,
-     *   },
-     *   status: 'finished',
-     *   // transfer_group: TransferGroup.identifier, // existing transfer group identifier
-     * }, {
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     *   create_wallet_if_not_exists: true,
-     *   return_balance: true,
-     * });
-     *
-     * expect(result).toEqual({
-     *   transfer: jasmine.objectContaining({
-     *     identifier: 'mycustomId',
-     *     token_foreign: 'ForeignForToken',
-     *     to_wallet_foreign: 'ForeignForWallet',
-     *     amount: 10.01,
-     *     metadata: {
-     *       customJsonBlob: true,
-     *     },
-     *     status: 'finished',
-     *     // ... other fields
-     *   }),
-     *   to_balance: jasmine.objectContaining({
-     *     token_foreign: 'ForeignForToken',
-     *     wallet_foreign: 'ForeignForWallet',
-     *     pending_amount: 0,
-     *     finished_amount: 10.01,
-     *     amount: 10.01,
-     *     // ... other fields
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {CreateDepositFnInput} input
-     * @param {CreateDepositFnOptions} [options]
-     * @returns {StreamPromise<CreateDepositFnOutput>}
-     *
-     */
-    createDeposit(input: CreateDepositFnInput, options?: CreateDepositFnOptions): StreamPromise<CreateDepositFnOutput>;
-    /**
-     *
-     * Create an exchange transfer group - change one token in certain amount for another token of certain amount
-     * The transfers are connected and either fail or succeed both
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createExchange({
-     *   identifier: 'exchange',
-     *   from_identifier: 'exchange1',
-     *   from_wallet: WALLETS.withEURFunds0.foreign,
-     *   from_token: 'EUR',
-     *   from_amount: 10,
-     *   to_identifier: 'exchange2',
-     *   to_token: 'USD',
-     *   to_wallet: WALLETS.withUSDFunds0.foreign,
-     *   to_amount: 20,
-     *   status: 'finished',
-     *   metadata: {
-     *     exchangeRate: 2,
-     *   },
-     * }, {
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     * expect(result).toEqual({
-     *   transfer_group: jasmine.objectContaining({
-     *     identifier: 'exchange',
-     *     status: 'closed',
-     *     transfer_status: 'finished',
-     *   }),
-     *   transfers: [
-     *     jasmine.objectContaining({
-     *       status: 'finished',
-     *       amount: 10,
-     *       from_wallet_id: WALLETS.withEURFunds0.id,
-     *       to_wallet_id: WALLETS.withUSDFunds0.id,
-     *       token_id: TOKENS.EUR.id,
-     *       metadata: {
-     *         exchangeRate: 2,
-     *       },
-     *       identifier: 'exchange1',
-     *     }),
-     *     jasmine.objectContaining({
-     *       status: 'finished',
-     *       amount: 20,
-     *       to_wallet_id: WALLETS.withEURFunds0.id,
-     *       from_wallet_id: WALLETS.withUSDFunds0.id,
-     *       token_id: TOKENS.USD.id,
-     *       metadata: {
-     *         exchangeRate: 2,
-     *       },
-     *       identifier: 'exchange2',
-     *     }),
-     *   ],
-     * });
-     *
-     * ```
-     *
-     * @param {CreateExchangeFnInput} input
-     * @param {CreateExchangeFnOptions} [options]
-     * @returns {StreamPromise<CreateExchangeFnOutput>}
-     *
-     */
-    createExchange(input: CreateExchangeFnInput, options?: CreateExchangeFnOptions): StreamPromise<CreateExchangeFnOutput>;
-    /**
-     *
-     * Create a new Token in the system which can then be transferred between wallets
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createToken(
-     *   {
-     *     foreign: 'EURO',
-     *     divisor: 10,
-     *     limit: 10,
-     *     public: true,
-     *     metadata: {
-     *       customMetadata: true,
-     *     },
-     *     // belongs_to: 'EURO-wallet'
-     *   },
-     *   {
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *   },
-     * );
-     *
-     * expect(result).toEqual({
-     *   token: jasmine.objectContaining({
-     *     foreign: 'EURO',
-     *     public: true,
-     *     metadata: {
-     *       customMetadata: true,
-     *     },
-     *   }),
-     *   wallet: jasmine.objectContaining({
-     *     default_allow_positive: false,
-     *     default_allow_negative: true,
-     *     foreign: 'EURO',
-     *     metadata: null,
-     *     type: 'token',
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {CreateTokenFnInput} input
-     * @param {CreateTokenFnOptions} [options]
-     * @returns {StreamPromise<CreateTokenFnOutput>}
-     *
-     */
-    createToken(input: CreateTokenFnInput, options?: CreateTokenFnOptions): StreamPromise<CreateTokenFnOutput>;
-    /**
-     *
-     * Create a transfer of Token amount from one wallet to the other.
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createTransfer({
-     *   identifier: 'mynewtransferid',
-     *   token: 'EUR',
-     *   from_wallet: WALLETS.withEURFunds0.foreign,
-     *   to_wallet: 'foreignForMbyExistingWallet',
-     *   amount: 10.01,
-     *   metadata: {
-     *     customJSON: true,
-     *   },
-     *   type: 'transfer',
-     *   status: 'pending',
-     *   // transfer_group: TransferGroup.identifier,
-     * }, {
-     *   create_to_wallet_if_not_exists: true,
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     *
-     * expect(result).toEqual({
-     *   transfer: jasmine.objectContaining({
-     *     identifier: 'mynewtransferid',
-     *     token_foreign: 'EUR',
-     *     from_wallet_foreign: WALLETS.withEURFunds0.foreign,
-     *     to_wallet_foreign: 'foreignForMbyExistingWallet',
-     *     amount: 10.01,
-     *     metadata: {
-     *       customJSON: true,
-     *     },
-     *     type: 'transfer',
-     *     status: 'pending',
-     *     // ...
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {CreateTransferFnInput} [input]
-     * @param {CreateTransferFnOptions} [options]
-     * @returns {StreamPromise<CreateTransferFnOutput>}
-     *
-     */
-    createTransfer(input?: CreateTransferFnInput, options?: CreateTransferFnOptions): StreamPromise<CreateTransferFnOutput>;
-    /**
-     *
-     * Create a TransferGroup entity to group transfers into a logical or status locked group.
-     * Can include the transfers in the same call or if non 'closed' TransferGroup, add the transfers later.
-     * Can also include child TransferGroups to create a hierarchy
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createTransferGroup({
-     *   identifier: 'mytgIdentifier',
-     *   status: 'closed',
-     *   metadata: {
-     *     customJSON: true,
-     *   },
-     *   transfer_status: 'finished',
-     *   // transfer_group: ParentTransferGroup.identifier,
-     *   children: [
-     *     {
-     *       identifier: 'txIdentifier',
-     *       from_wallet: WALLETS.withEURFunds0.foreign,
-     *       to_wallet: 'newWalletForeign',
-     *       token: 'EUR',
-     *       amount: 10,
-     *       type: 'transfer',
-     *       latest_control_hash: WALLETS.withEURFunds0.latest_control_hash,
-     *     },
-     *     {
-     *       identifier: 'childTgTransferId',
-     *       from_wallet: 'newWalletForeign',
-     *       to_wallet: WALLETS.withEURFunds0.foreign,
-     *       token: 'EUR',
-     *       amount: 9,
-     *       type: 'transfer',
-     *       latest_control_hash: null, // not needed because we just transferred money there,
-     *     },
-     *   ],
-     * }, {
-     *   validate_final_balance_only: true,
-     *   create_to_wallet_if_not_exists: true,
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     *
-     * expect(result).toEqual(jasmine.objectContaining({
-     *   transfer_group: jasmine.objectContaining({
-     *     identifier: 'mytgIdentifier',
-     *     status: 'closed',
-     *     metadata: {
-     *       customJSON: true,
-     *     },
-     *     transfer_status: 'finished',
-     *   }),
-     *   transfers: [
-     *     jasmine.objectContaining({
-     *       identifier: 'txIdentifier',
-     *       from_wallet_foreign: WALLETS.withEURFunds0.foreign,
-     *       to_wallet_foreign: 'newWalletForeign',
-     *       token_foreign: 'EUR',
-     *       amount: 10,
-     *       type: 'transfer',
-     *     }),
-     *     jasmine.objectContaining({
-     *       identifier: 'childTgTransferId',
-     *       from_wallet_foreign: 'newWalletForeign',
-     *       to_wallet_foreign: WALLETS.withEURFunds0.foreign,
-     *       token_foreign: 'EUR',
-     *       amount: 9,
-     *       type: 'transfer',
-     *     }),
-     *   ],
-     * }));
-     *
-     *
-     * ```
-     *
-     * @param {CreateTransferGroupFnInput} input
-     * @param {CreateTransferGroupFnOptions} [options]
-     * @returns {StreamPromise<CreateTransferGroupFnOutput>}
-     *
-     */
-    createTransferGroup(input: CreateTransferGroupFnInput, options?: CreateTransferGroupFnOptions): StreamPromise<CreateTransferGroupFnOutput>;
-    /**
-     *
-     * Create multiple transfers with one call. Transfers are created in a transaction so it either succeeds or fails as one.
-     * Will respect internal balance transfers to avoid latest_control_hash
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createTransfers({
-     *   transfers: [{
-     *     type: 'deposit',
-     *     wallet: WALLETS.validForeign2,
-     *     token: 'EURO',
-     *     amount: 10.01,
-     *   }, {
-     *     from_wallet: WALLETS.validForeign2,
-     *     to_wallet: 'newWalletForeignMby',
-     *     token: 'EURO',
-     *     amount: 10.01,
-     *     latest_control_hash: null, // not required as we just transferred funds
-     *   }, {
-     *     type: 'withdrawal',
-     *     wallet: 'newWalletForeignMby',
-     *     token: 'EURO',
-     *     amount: 10.01,
-     *     latest_control_hash: null, // not required as we just transferred funds
-     *   }],
-     * }, {
-     *   create_to_wallet_if_not_exists: true,
-     *   return_from_balance: true,
-     *   return_to_balance: true,
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     *
-     * expect(result).toEqual(jasmine.objectContaining({
-     *   transfers: [
-     *     jasmine.objectContaining({
-     *       type: 'deposit',
-     *       token_foreign: 'EURO',
-     *       to_wallet_foreign: WALLETS.validForeign2,
-     *       amount: 10.01,
-     *     }),
-     *     jasmine.objectContaining({
-     *       type: 'transfer',
-     *       token_foreign: 'EURO',
-     *       from_wallet_foreign: WALLETS.validForeign2,
-     *       to_wallet_foreign: 'newWalletForeignMby',
-     *       amount: 10.01,
-     *     }),
-     *     jasmine.objectContaining({
-     *       type: 'withdrawal',
-     *       token_foreign: 'EURO',
-     *       from_wallet_foreign: 'newWalletForeignMby',
-     *       amount: 10.01,
-     *     }),
-     *   ],
-     *   // We are doing a 0 sum with 3 transactions so everything is back to 0
-     *   from_balances: [
-     *     jasmine.objectContaining({
-     *       token_foreign: 'EURO',
-     *       wallet_foreign: 'EURO',
-     *       amount: 0,
-     *     }),
-     *     jasmine.objectContaining({
-     *       token_foreign: 'EURO',
-     *       wallet_foreign: WALLETS.validForeign2,
-     *       amount: 0,
-     *     }),
-     *     jasmine.objectContaining({
-     *       token_foreign: 'EURO',
-     *       wallet_foreign: 'newWalletForeignMby',
-     *       amount: 0,
-     *     }),
-     *   ],
-     *   to_balances: [
-     *     jasmine.objectContaining({
-     *       token_foreign: 'EURO',
-     *       wallet_foreign: WALLETS.validForeign2,
-     *       amount: 0,
-     *     }),
-     *     jasmine.objectContaining({
-     *       token_foreign: 'EURO',
-     *       wallet_foreign: 'newWalletForeignMby',
-     *       amount: 0,
-     *     }),
-     *     jasmine.objectContaining({
-     *       token_foreign: 'EURO',
-     *       wallet_foreign: 'EURO',
-     *       amount: 0,
-     *     }),
-     *   ],
-     * }));
-     *
-     *
-     * ```
-     *
-     * @param {CreateTransfersFnInput} input
-     * @param {CreateTransfersFnOptions} [options]
-     * @returns {StreamPromise<CreateTransfersFnOutput>}
-     *
-     */
-    createTransfers(input: CreateTransfersFnInput, options?: CreateTransfersFnOptions): StreamPromise<CreateTransfersFnOutput>;
-    /**
-     *
-     * Create a Wallet entity which can then transfer amounts of Tokens.
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createWallet({
-     *   foreign: 'test-wallet-2',
-     *   name: 'Irrelevant',
-     *   metadata: {
-     *     awesome: true,
-     *     invalid: false,
-     *   },
-     * }, {
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     *
-     * expect(result).toEqual({
-     *   wallet: jasmine.objectContaining({
-     *     foreign: 'test-wallet-2',
-     *     name: 'Irrelevant',
-     *     metadata: {
-     *       awesome: true,
-     *       invalid: false,
-     *     },
-     *   }),
-     * });
-     *
-     *
-     * ```
-     *
-     * @param {CreateWalletFnInput} input
-     * @param {CreateWalletFnOptions} [options]
-     * @returns {StreamPromise<CreateWalletFnOutput>}
-     *
-     */
-    createWallet(input: CreateWalletFnInput, options?: CreateWalletFnOptions): StreamPromise<CreateWalletFnOutput>;
-    /**
-     *
-     * Create a transfer withdrawing funds from a Wallet.
-     * Will default to transferring funds to Token default Wallet.
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.createWithdrawal({
-     *   identifier: 'mycustomId',
-     *   token: 'ForeignForToken',
-     *   wallet: 'ForeignForWallet',
-     *   amount: 10.01,
-     *   metadata: {
-     *     customJsonBlob: true,
-     *   },
-     *   status: 'finished',
-     *   latest_control_hash: null,
-     *   // transfer_group: TransferGroup.identifier, // existing transfer group identifier
-     * }, {
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     *   return_balance: true,
-     * });
-     *
-     * expect(result).toEqual({
-     *   transfer: jasmine.objectContaining({
-     *     identifier: 'mycustomId',
-     *     token_foreign: 'ForeignForToken',
-     *     from_wallet_foreign: 'ForeignForWallet',
-     *     amount: 10.01,
-     *     metadata: {
-     *       customJsonBlob: true,
-     *     },
-     *     status: 'finished',
-     *     // ... other fields
-     *   }),
-     *   from_balance: jasmine.objectContaining({
-     *     token_foreign: 'ForeignForToken',
-     *     wallet_foreign: 'ForeignForWallet',
-     *     pending_amount: 0,
-     *     finished_amount: 89.99,
-     *     amount: 89.99,
-     *     // ... other fields
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {CreateWithdrawalFnInput} input
-     * @param {CreateWithdrawalFnOptions} [options]
-     * @returns {StreamPromise<CreateWithdrawalFnOutput>}
-     *
-     */
-    createWithdrawal(input: CreateWithdrawalFnInput, options?: CreateWithdrawalFnOptions): StreamPromise<CreateWithdrawalFnOutput>;
-    /**
-     *
-     * Search for Balances using either a simple filter or queryBuilder
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.findBalances()
-     *   .where({
-     *     wallet: WALLETS.validId0,
-     *   })
-     *   .orWhere('amount', '>', 100)
-     *   .orWhere({
-     *     wallet: WALLETS.validId1,
-     *     token: 'USD',
-     *   })
-     *   .orWhere(builder => {
-     *     builder.where('updated_at', '<', '2020-01-01')
-     *       .where('amount', '<', -1000000);
-     *   })
-     *   .limit(5)
-     *   .offset(0)
-     *   .orderBy('amount', 'desc')
-     *   .options({
-     *     tracking_id: 'hello',
-     *     return_metadata_total: true,
-     *   });
-     *
-     * ```
-     *
-     * @param {FindBalancesFnInput} [input]
-     * @param {FindBalancesFnOptions} [options]
-     * @returns {StreamPromise<FindBalancesFnOutput>}
-     *
-     */
-    findBalances(): QueryBuilder<FindBalancesFnFields, FindBalancesFnStringFields, FindBalancesFnMetadataFields, FindBalancesFnResultFields, FindBalancesFnOptions, FindBalancesFnOutput>;
-    findBalances(input: FindBalancesFnInput, options?: FindBalancesFnOptions): StreamPromise<FindBalancesFnOutput>;
-    /**
-     *
-     * Search for Tokens using either a simple filter or queryBuilder
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.findTokens()
-     *   .where({
-     *     metadata: {
-     *       even: true,
-     *       example: 'test',
-     *     },
-     *   })
-     *   .orWhere({
-     *     foreign: 'token-example1',
-     *   })
-     *   .limit(5)
-     *   .offset(0)
-     *   .orderBy(['foreign', {column: 'id', order: 'desc'}])
-     *   .options({
-     *     tracking_id: 'hello',
-     *     return_metadata_total: true,
-     *   });
-     *
-     * ```
-     *
-     * @param {FindTokensFnInput} [input]
-     * @param {FindTokensFnOptions} [options]
-     * @returns {StreamPromise<FindTokensFnOutput>}
-     *
-     */
-    findTokens(): QueryBuilder<FindTokensFnFields, FindTokensFnStringFields, FindTokensFnMetadataFields, FindTokensFnResultFields, FindTokensFnOptions, FindTokensFnOutput>;
-    findTokens(input: FindTokensFnInput, options?: FindTokensFnOptions): StreamPromise<FindTokensFnOutput>;
-    /**
-     *
-     * Search for TransferGroups using either a simple filter or queryBuilder
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.findTransferGroups()
-     *   .where({
-     *     metadata: {
-     *       even: true,
-     *       example: 'test',
-     *     },
-     *   })
-     *   .orWhere({
-     *     identifier: 'reverser-example',
-     *   })
-     *   .orWhere(builder => {
-     *     builder.where({
-     *       metadata: {
-     *         kak: true,
-     *       },
-     *     })
-     *       .where('created_at', '>', '2020-01-01');
-     *   })
-     *   .limit(5)
-     *   .offset(0)
-     *   .orderBy('id', 'desc')
-     *   .select('id', 'type', 'identifier')
-     *   .options({
-     *     tracking_id: 'hello',
-     *     return_metadata_total: true,
-     *   });
-     *
-     * ```
-     *
-     * @param {FindTransferGroupsFnInput} [input]
-     * @param {FindTransferGroupsFnOptions} [options]
-     * @returns {StreamPromise<FindTransferGroupsFnOutput>}
-     *
-     */
-    findTransferGroups(): QueryBuilder<FindTransferGroupsFnFields, FindTransferGroupsFnStringFields, FindTransferGroupsFnMetadataFields, FindTransferGroupsFnResultFields, FindTransferGroupsFnOptions, FindTransferGroupsFnOutput>;
-    findTransferGroups(input: FindTransferGroupsFnInput, options?: FindTransferGroupsFnOptions): StreamPromise<FindTransferGroupsFnOutput>;
-    /**
-     *
-     * Search for Transfers using either a simple filter or queryBuilder
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.findTransfers()
-     *   .where({
-     *     metadata: {
-     *       example: true,
-     *     },
-     *   })
-     *   .where('id', '>', 1)
-     *   .where(builder => {
-     *     builder.where('status', 'finished')
-     *       .orWhere('type', 'deposit');
-     *   })
-     *   .limit(5)
-     *   .offset(0)
-     *   .orderBy(['token_id', {column: 'id', order: 'desc'}])
-     *   .select('id', 'type', 'from_wallet_foreign', 'to_wallet_foreign')
-     *   .options({
-     *     tracking_id: 'hello',
-     *   });
-     *
-     * ```
-     *
-     * @param {FindTransfersFnInput} [input]
-     * @param {FindTransfersFnOptions} [options]
-     * @returns {StreamPromise<FindTransfersFnOutput>}
-     *
-     */
-    findTransfers(): QueryBuilder<FindTransfersFnFields, FindTransfersFnStringFields, FindTransfersFnMetadataFields, FindTransfersFnResultFields, FindTransfersFnOptions, FindTransfersFnOutput>;
-    findTransfers(input: FindTransfersFnInput, options?: FindTransfersFnOptions): StreamPromise<FindTransfersFnOutput>;
-    /**
-     *
-     * Search for Wallets using either a simple filter or queryBuilder
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.findWallets()
-     *   .where({
-     *     metadata: {
-     *       general: true,
-     *     },
-     *   })
-     *   .where('id', '>', 1)
-     *   .where(builder => {
-     *     builder
-     *       .whereMetadata('tost', 10)
-     *       .orWhereMetadata('test', 1);
-     *   })
-     *   .limit(5)
-     *   .offset(0)
-     *   .orderBy(['status', {column: 'id', order: 'desc'}])
-     *   .select('id')
-     *   .options({
-     *     tracking_id: 'hello',
-     *   });
-     *
-     * ```
-     *
-     * @param {FindWalletsFnInput} [input]
-     * @param {FindWalletsFnOptions} [options]
-     * @returns {StreamPromise<FindWalletsFnOutput>}
-     *
-     */
-    findWallets(): QueryBuilder<FindWalletsFnFields, FindWalletsFnStringFields, FindWalletsFnMetadataFields, FindWalletsFnResultFields, FindWalletsFnOptions, FindWalletsFnOutput>;
-    findWallets(input: FindWalletsFnInput, options?: FindWalletsFnOptions): StreamPromise<FindWalletsFnOutput>;
-    /**
-     *
-     * Get a specific token/wallet balance
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.getBalance({
-     *   wallet: 'myMbyExistingWallet',
-     *   token: 'MBYTOKEN',
-     *   datetime: '2020-01-01',
-     * }, {
-     *   create_wallet_if_not_exists: true,
-     *   create_token_if_not_exists: true,
-     *   create_if_not_exists: true,
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     *
-     * expect(result).toEqual({
-     *   balance: jasmine.objectContaining({
-     *     wallet_foreign: 'myMbyExistingWallet',
-     *     token_foreign: 'MBYTOKEN',
-     *     pending_amount: 0,
-     *     finished_amount: 0,
-     *     amount: 0,
-     *     latest_control_hash: null,
-     *     available_balance: 0,
-     *     // ...
-     *   }),
-     * });
-     *
-     *
-     * ```
-     *
-     * @param {GetBalanceFnInput} input
-     * @param {GetBalanceFnOptions} [options]
-     * @returns {StreamPromise<GetBalanceFnOutput>}
-     *
-     */
-    getBalance(input: GetBalanceFnInput, options?: GetBalanceFnOptions): StreamPromise<GetBalanceFnOutput>;
-    /**
-     *
-     * Get a list of changes to token/wallet balance
-     *
-     * ```javascript
-     *
-     * // setup
-     * const deposit = await wapiClient.createDeposit({
-     *   wallet: 'newWallet',
-     *   amount: 10,
-     *   status: 'pending',
-     *   identifier: 'depositUSD',
-     *   token: 'USD',
-     * }, {
-     *   create_wallet_if_not_exists: true,
-     * });
-     * const updatedTransfer = await wapiClient.updateTransfer({
-     *   transfer: 'depositUSD',
-     *   status: 'finished',
-     * });
-     *
-     * const result = await wapiClient.getBalanceHistory({
-     *   wallet: 'newWallet',
-     *   token: 'USD',
-     * }, {
-     *   create_token_if_not_exists: true,
-     *   create_wallet_if_not_exists: true,
-     *   limit: 5,
-     *   select: [
-     *     'transfer_identifier',
-     *     'pending_amount',
-     *     'finished_amount',
-     *     'pending_amount_from',
-     *     'pending_amount_to',
-     *     'amount',
-     *     // 'balance_id',
-     *     // 'transfer_id',
-     *     // 'transfer_control_hash',
-     *     // 'transfer_from_wallet_id',
-     *     // 'transfer_from_wallet_foreign',
-     *     // 'transfer_to_wallet_id',
-     *     // 'transfer_to_wallet_foreign',
-     *     // 'transfer_amount',
-     *     // 'transfer_type',
-     *     // 'transfer_status',
-     *     // 'transfer_force',
-     *     // 'transfer_created_at',
-     *     // 'transfer_updated_at',
-     *     // 'transfer_metadata',
-     *     // 'transfer_transfer_group_id',
-     *     // 'transfer_transfer_group_identifier',
-     *     // 'transfer_reverses_id',
-     *     // 'transfer_reverses_identifier',
-     *     // 'transfer_status_finalized_at',
-     *     // 'token_id',
-     *     // 'token_foreign',
-     *     // 'wallet_id',
-     *     // 'wallet_foreign',
-     *     // 'latest_control_hash',
-     *     // 'updated_at',
-     *   ],
-     *   offset: 0,
-     *   order: 'desc',
-     *   return_metadata_total: true,
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     * expect(result).toEqual({
-     *   balances: [
-     *     {
-     *       transfer_identifier: 'depositUSD',
-     *       pending_amount: 0,
-     *       finished_amount: 10,
-     *       pending_amount_to: 0,
-     *       pending_amount_from: 0,
-     *       amount: 10,
-     *     },
-     *     {
-     *       transfer_identifier: 'depositUSD',
-     *       pending_amount: 10,
-     *       finished_amount: 0,
-     *       pending_amount_to: 10,
-     *       pending_amount_from: 0,
-     *       amount: 10,
-     *     },
-     *   ],
-     *   metadata: {
-     *     limit: 5,
-     *     offset: 0,
-     *     total: 2,
-     *     more_rows: false,
-     *   },
-     * });
-     *
-     * ```
-     *
-     * @param {GetBalanceHistoryFnInput} input
-     * @param {GetBalanceHistoryFnOptions} [options]
-     * @returns {StreamPromise<GetBalanceHistoryFnOutput>}
-     *
-     */
-    getBalanceHistory(input: GetBalanceHistoryFnInput, options?: GetBalanceHistoryFnOptions): StreamPromise<GetBalanceHistoryFnOutput>;
-    /**
-     *
-     * Retrieve the current state of configurable Flags for your WAPI instance
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.getFlags();
-     * expect(result.flags).toEqual({
-     *   production: true,
-     *   allow_timestamps: false,
-     * });
-     *
-     * ```
-     *
-     * @param {GetFlagsFnInput} [input]
-     * @param {GetFlagsFnOptions} [options]
-     * @returns {StreamPromise<GetFlagsFnOutput>}
-     *
-     */
-    getFlags(input?: GetFlagsFnInput, options?: GetFlagsFnOptions): StreamPromise<GetFlagsFnOutput>;
-    /**
-     *
-     * Get aggregated statistics about WAPI entities
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.getStatistics({
-     *   model: 'Transfer',
-     *   aggregator: 'count',
-     *   groups: [{
-     *     type: 'period',
-     *     field: {
-     *       period: 'month',
-     *       timezone: 'Europe/Tallinn',
-     *     },
-     *   }],
-     *   filter: {
-     *     end_time: (new Date(`${new Date().getFullYear() + 1}-01-01`)).toISOString(),
-     *     start_time: (new Date(`${new Date().getFullYear()}-01-01`)).toISOString(),
-     *   },
-     * }, {
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     *
-     * expect(result).toEqual({
-     *   rows: [
-     *     {
-     *       aggregate: 3,
-     *       period: `${new Date().getFullYear()}-${(new Date().getMonth() + 1 + '').padStart(2, '0')}`,
-     *     },
-     *   ],
-     * });
-     *
-     * ```
-     *
-     * @param {GetStatisticsFnInput} [input]
-     * @param {GetStatisticsFnOptions} [options]
-     * @returns {StreamPromise<GetStatisticsFnOutput>}
-     *
-     */
-    getStatistics(input?: GetStatisticsFnInput, options?: GetStatisticsFnOptions): StreamPromise<GetStatisticsFnOutput>;
-    /**
-     *
-     * Get information about token
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.getToken({
-     *   foreign: 'EURO',
-     * }, {
-     *   create_if_not_exists: true,
-     *   // return_only_id: true, // for example purposes we want more than id
-     *   ignore_cache: true,
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     *
-     * expect(result).toEqual({
-     *   token: jasmine.objectContaining({
-     *     foreign: 'EURO',
-     *     metadata: null,
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {GetTokenFnInput} [input]
-     * @param {GetTokenFnOptions} [options]
-     * @returns {StreamPromise<GetTokenFnOutput>}
-     *
-     */
-    getToken(input?: GetTokenFnInput, options?: GetTokenFnOptions): StreamPromise<GetTokenFnOutput>;
-    /**
-     *
-     * Get information about a specific transfer
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.getTransfer({
-     *   transfer: 'get-transfer-test',
-     * }, {
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     * expect(result).toEqual({
-     *   transfer: jasmine.objectContaining({
-     *     identifier: 'get-transfer-test',
-     *     // ...
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {GetTransferFnInput} input
-     * @param {GetTransferFnOptions} [options]
-     * @returns {StreamPromise<GetTransferFnOutput>}
-     *
-     */
-    getTransfer(input: GetTransferFnInput, options?: GetTransferFnOptions): StreamPromise<GetTransferFnOutput>;
-    /**
-     *
-     * Get TransferGroup information
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.getTransferGroup({
-     *   transfer_group: 'customIdentifier',
-     * }, {
-     *   create_if_not_exists: true,
-     *   // return_only_id: true, // example requires more than just ID
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     * expect(result).toEqual({
-     *   transfer_group: jasmine.objectContaining({
-     *     identifier: 'customIdentifier',
-     *     metadata: null,
-     *     status: 'open',
-     *     transfer_status: 'pending',
-     *     status_finalized_at: null,
-     *     transfer_status_finalized_at: null,
-     *     reverses_id: null,
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {GetTransferGroupFnInput} input
-     * @param {GetTransferGroupFnOptions} [options]
-     * @returns {StreamPromise<GetTransferGroupFnOutput>}
-     *
-     */
-    getTransferGroup(input: GetTransferGroupFnInput, options?: GetTransferGroupFnOptions): StreamPromise<GetTransferGroupFnOutput>;
-    /**
-     *
-     * Get information about wallet
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.getWallet({
-     *   wallet: WALLETS.withEURFunds0.foreign,
-     * }, {
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     *   ignore_cache: true,
-     *   create_if_not_exists: true,
-     *   return_only_id: false,
-     * });
-     * expect(result).toEqual({
-     *   wallet: jasmine.objectContaining({
-     *     foreign: WALLETS.withEURFunds0.foreign,
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {GetWalletFnInput} input
-     * @param {GetWalletFnOptions} [options]
-     * @returns {StreamPromise<GetWalletFnOutput>}
-     *
-     */
-    getWallet(input: GetWalletFnInput, options?: GetWalletFnOptions): StreamPromise<GetWalletFnOutput>;
-    /**
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.importData().input(async (stream) => {
-     *   const fileStream = createReadStream(join(__dirname, '../lib/short-import.txt'));
-     *
-     *   const rl = createInterface({
-     *     input: fileStream,
-     *     crlfDelay: Infinity
-     *   });
-     *   for await (const line of rl) {
-     *     // Each line in input.txt will be successively available here as `line`.
-     *     if (!line) {
-     *       continue;
-     *     }
-     *     const obj = JSON.parse(line);
-     *     stream.write(obj);
-     *   }
-     *   stream.end();
-     * });
-     *
-     * ```
-     *
-     * @param {ImportDataFnInput} [input]
-     * @param {ImportDataFnOptions} [options]
-     * @returns {StreamPromise<ImportDataFnOutput>}
-     *
-     */
-    importData(options?: ImportDataFnOptions): StreamPromiseInput<ImportDataFnOutput, ImportDataFnStreamChunk>;
-    importData(input: ImportDataFnInput, options?: ImportDataFnOptions): StreamPromise<ImportDataFnOutput>;
-    /**
-     *
-     * Reverse a transfer of value between two wallets
-     * will cancel pending transfers and create opposite transfers for finished ones.
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.reverseTransfer({
-     *   transfer: 'MYDEPOSIT',
-     *   status: 'finished',
-     *   identifier: 'MYREVERSEDEPOSIT',
-     *   force: true,
-     *   // metadata: {},
-     *   metadata: {
-     *     extraCustomJSON: true,
-     *   },
-     * }, {
-     *   reverse_deposit: true,
-     *   reverse_withdrawal: true,
-     *   return_to_balance: true,
-     *   return_from_balance: true,
-     *   metadata_action: 'extend',
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     * expect(result).toEqual({
-     *   transfer: jasmine.objectContaining({
-     *     identifier: 'MYREVERSEDEPOSIT',
-     *     amount: 10.01,
-     *     type: 'withdrawal',
-     *     status: 'finished',
-     *     force: true,
-     *     metadata: {
-     *       customJSON: true,
-     *       extraCustomJSON: true,
-     *     },
-     *     transfer_group_id: null,
-     *     reverses_id: DEPOSIT.id,
-     *     from_wallet_foreign: DEPOSIT.to_wallet_foreign,
-     *     to_wallet_foreign: DEPOSIT.from_wallet_foreign,
-     *     token_foreign: DEPOSIT.token_foreign,
-     *     // ...
-     *   }),
-     *   to_balance: jasmine.objectContaining({
-     *     token_foreign: DEPOSIT.token_foreign,
-     *     wallet_foreign: DEPOSIT.from_wallet_foreign,
-     *     // ...
-     *   }),
-     *   from_balance: jasmine.objectContaining({
-     *     token_foreign: DEPOSIT.token_foreign,
-     *     wallet_foreign: DEPOSIT.to_wallet_foreign,
-     *     // ...
-     *   }),
-     * });
-     *
-     * ```
-     *
-     * @param {ReverseTransferFnInput} input
-     * @param {ReverseTransferFnOptions} [options]
-     * @returns {StreamPromise<ReverseTransferFnOutput>}
-     *
-     */
-    reverseTransfer(input: ReverseTransferFnInput, options?: ReverseTransferFnOptions): StreamPromise<ReverseTransferFnOutput>;
-    /**
-     *
-     * Similar to reverseTransfer will reverse value transfers, however it will reverse the whole
-     * group with its children by creating a new group with opposite transfers.
-     *
-     * ```javascript
-     *
-     * // Should succeed if flag is set
-     * const result = await wapiClient.reverseTransferGroup({
-     *   transfer_group: 'myCustom',
-     *   identifier: 'myCustomReverse',
-     *   metadata: {
-     *     extraCustomJSON: true,
-     *   },
-     *   transfer_status: 'finished',
-     * }, {
-     *   validate_final_balance_only: true,
-     *   reverse_deposit: true,
-     *   reverse_withdrawal: true,
-     *   return_transfers: true,
-     *   metadata_action: 'extend',
-     *   transfer_metadata_action: 'extend',
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     *
-     * expect(result).toEqual({
-     *   transfer_group: jasmine.objectContaining({
-     *     identifier: 'myCustomReverse',
-     *     status: 'closed',
-     *     metadata: {
-     *       customJSON: true,
-     *       extraCustomJSON: true,
-     *     },
-     *     transfer_status: 'finished',
-     *   }),
-     *   transfers: [
-     *     jasmine.objectContaining({
-     *       from_wallet_foreign: 'myWallet2',
-     *       to_wallet_foreign: 'myWallet1',
-     *       amount: 8,
-     *       type: 'transfer',
-     *       status: 'finished',
-     *       token_foreign: 'EUR',
-     *     }),
-     *     jasmine.objectContaining({
-     *       from_wallet_foreign: 'myWallet1',
-     *       to_wallet_foreign: 'EUR',
-     *       amount: 10,
-     *       type: 'withdrawal',
-     *       status: 'finished',
-     *       token_foreign: 'EUR',
-     *     }),
-     *   ],
-     * });
-     *
-     * ```
-     *
-     * @param {ReverseTransferGroupFnInput} input
-     * @param {ReverseTransferGroupFnOptions} [options]
-     * @returns {StreamPromise<ReverseTransferGroupFnOutput>}
-     *
-     */
-    reverseTransferGroup(input: ReverseTransferGroupFnInput, options?: ReverseTransferGroupFnOptions): StreamPromise<ReverseTransferGroupFnOutput>;
-    /**
-     *
-     *
-     * ```javascript
-     *
-     * const [[finishedTransfer1], [finishedTransfer2]] = await Promise.all([
-     *   TEST.knex('transfers').insert({
-     *     identifier: getTxIdSync(),
-     *     auto_hash: true,
-     *     amount: toNumberInput(10.12),
-     *     status: 'finished',
-     *     metadata: {
-     *       example: 'test'
-     *     },
-     *     from_wallet_id: WALLETS.withEURFunds0.id,
-     *     to_wallet_id: WALLETS.validId1,
-     *     token_id: TOKENS.EUR.id,
-     *   }).returning('*'),
-     *   TEST.knex('transfers').insert({
-     *     identifier: getTxIdSync(),
-     *     auto_hash: true,
-     *     amount: toNumberInput(10.12),
-     *     status: 'finished',
-     *     metadata: {
-     *       example: 'test'
-     *     },
-     *     from_wallet_id: WALLETS.withEURFunds0.id,
-     *     to_wallet_id: WALLETS.validId1,
-     *     token_id: TOKENS.EUR.id,
-     *   }).returning('*'),
-     * ]);
-     *
-     * const result = await wapiClient.reverseTransfers({
-     *   metadata: {
-     *     example: 'test'
-     *   },
-     * });
-     *
-     * const { transfers } = result;
-     * expect(transfers.length).toEqual(2);
-     *
-     * expect(transfers[0].identifier).not.toEqual(finishedTransfer1.identifier);
-     * expect(transfers[0].amount).toEqual(formatNumber(finishedTransfer1.amount));
-     * expect(transfers[0].from_wallet_id).toEqual(finishedTransfer1.to_wallet_id);
-     * expect(transfers[0].to_wallet_id).toEqual(finishedTransfer1.from_wallet_id);
-     *
-     * expect(transfers[1].identifier).not.toEqual(finishedTransfer2.identifier);
-     * expect(transfers[1].amount).toEqual(formatNumber(finishedTransfer2.amount));
-     * expect(transfers[1].from_wallet_id).toEqual(finishedTransfer2.to_wallet_id);
-     * expect(transfers[1].to_wallet_id).toEqual(finishedTransfer2.from_wallet_id);
-     *
-     * ```
-     *
-     * @param {ReverseTransfersFnInput} [input]
-     * @param {ReverseTransfersFnOptions} [options]
-     * @returns {StreamPromise<ReverseTransfersFnOutput>}
-     *
-     */
-    reverseTransfers(): ReverseQueryBuilder<ReverseTransfersFnFields, ReverseTransfersFnStringFields, ReverseTransfersFnMetadataFields, ReverseTransfersFnModifications, ReverseTransfersFnOutput>;
-    reverseTransfers(input: ReverseTransfersFnInput, options?: ReverseTransfersFnOptions): StreamPromise<ReverseTransfersFnOutput>;
-    /**
-     *
-     * Configure WAPI instance Flags
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.setFlags({
-     *   production: false,
-     *   allow_timestamps: true,
-     * }, {
-     *   tracking_id: 'mylog',
-     * });
-     * expect(result).toEqual({
-     *   flags: {
-     *     production: false,
-     *     allow_timestamps: true,
-     *   },
-     *   message: 'flag updated, reconnect to apply',
-     * });
-     *
-     * ```
-     *
-     * @param {SetFlagsFnInput} input
-     * @param {SetFlagsFnOptions} [options]
-     * @returns {StreamPromise<SetFlagsFnOutput>}
-     *
-     */
-    setFlags(input: SetFlagsFnInput, options?: SetFlagsFnOptions): StreamPromise<SetFlagsFnOutput>;
-    /**
-     * Update token object
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.updateToken(
-     *   {
-     *     token: TOKENS.EUR.foreign,
-     *     public: false,
-     *     metadata: {
-     *       metadata_field: 2,
-     *     },
-     *     status: 'disabled',
-     *   },
-     *   {
-     *     return_when_not_updated: true,
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *   },
-     * );
-     * expect(result).toEqual({
-     *   token: jasmine.objectContaining({
-     *     belongs_to: TOKENS.EUR.belongs_to,
-     *     divisor: TOKENS.EUR.divisor,
-     *     id: TOKENS.EUR.id,
-     *     limit: TOKENS.EUR.limit,
-     *     metadata: {
-     *       metadata_field: 2,
-     *     },
-     *     type: TOKENS.EUR.type,
-     *     foreign: TOKENS.EUR.foreign,
-     *     public: false,
-     *     status: 'disabled',
-     *   }),
-     *   updated: true,
-     * });
-     *
-     * ```
-     *
-     * @param {UpdateTokenFnInput} input
-     * @param {UpdateTokenFnOptions} [options]
-     * @returns {StreamPromise<UpdateTokenFnOutput>}
-     *
-     */
-    updateToken(input: UpdateTokenFnInput, options?: UpdateTokenFnOptions): StreamPromise<UpdateTokenFnOutput>;
-    /**
-     *
-     * Update the status of a Transfer (pending to finished or cancelled)
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.updateTransfer({
-     *   transfer: 'myPendingDeposit',
-     *   status: 'cancelled',
-     *   metadata: {
-     *     meta: 'new',
-     *     was: true,
-     *   },
-     * }, {
-     *   return_from_balance: true,
-     *   return_to_balance: true,
-     *   return_when_not_updated: true,
-     *   metadata_action: 'extend',
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     * expect(result).toEqual({
-     *   transfer: jasmine.objectContaining({
-     *     identifier: 'myPendingDeposit',
-     *     amount: 10.01,
-     *     type: 'deposit',
-     *     status: 'cancelled',
-     *     transfer_group_id: null,
-     *     reverses_id: null,
-     *     from_wallet_foreign: 'EURO',
-     *     to_wallet_foreign: 'myWallet',
-     *     token_foreign: 'EURO',
-     *     metadata: {
-     *       meta: 'new',
-     *       is: true,
-     *       was: true,
-     *     }
-     *   }),
-     *   to_balance: jasmine.objectContaining({
-     *     token_foreign: 'EURO',
-     *     wallet_foreign: 'myWallet',
-     *     pending_amount: 0,
-     *     finished_amount: 0,
-     *     amount: 0,
-     *   }),
-     *   from_balance: jasmine.objectContaining({
-     *     token_foreign: 'EURO',
-     *     wallet_foreign: 'EURO',
-     *     pending_amount: 0,
-     *     finished_amount: 0,
-     *     amount: 0,
-     *   }),
-     *   updated: true,
-     * });
-     *
-     * ```
-     *
-     * @param {UpdateTransferFnInput} input
-     * @param {UpdateTransferFnOptions} [options]
-     * @returns {StreamPromise<UpdateTransferFnOutput>}
-     *
-     */
-    updateTransfer(input: UpdateTransferFnInput, options?: UpdateTransferFnOptions): StreamPromise<UpdateTransferFnOutput>;
-    /**
-     *
-     * Update the status and transfer_status of a TransferGroup
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.updateTransferGroup({
-     *   transfer_group: 'myCustom',
-     *   status: 'closed',
-     *   transfer_status: 'finished',
-     * }, {
-     *   return_transfers: true,
-     *   return_when_not_updated: true,
-     *   tracking_id: 'mylogId',
-     *   // transaction_id: Transaction.identifier, // created transaction identifier
-     * });
-     * expect(result).toEqual({
-     *   transfer_group: jasmine.objectContaining({
-     *     identifier: 'myCustom',
-     *     status: 'closed',
-     *     transfer_status: 'finished',
-     *   }),
-     *   transfers: [
-     *     jasmine.objectContaining({
-     *       identifier: 'transferA',
-     *       type: 'deposit',
-     *       status: 'finished',
-     *       from_wallet_foreign: 'EUR',
-     *       to_wallet_foreign: 'myWallet1',
-     *       token_foreign: 'EUR',
-     *     }),
-     *     jasmine.objectContaining({
-     *       identifier: 'transferB',
-     *       type: 'transfer',
-     *       status: 'finished',
-     *       from_wallet_foreign: 'myWallet1',
-     *       to_wallet_foreign: 'myWallet2',
-     *       token_foreign: 'EUR',
-     *     }),
-     *   ],
-     *   updated: true,
-     * });
-     *
-     * ```
-     *
-     * @param {UpdateTransferGroupFnInput} input
-     * @param {UpdateTransferGroupFnOptions} [options]
-     * @returns {StreamPromise<UpdateTransferGroupFnOutput>}
-     *
-     */
-    updateTransferGroup(input: UpdateTransferGroupFnInput, options?: UpdateTransferGroupFnOptions): StreamPromise<UpdateTransferGroupFnOutput>;
-    /**
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.updateTransferGroups()
-     *   .where({
-     *     status: 'open',
-     *   })
-     *   .whereIn('identifier', ['transferGroup1', 'transferGroup2'])
-     *   .whereMetadata('old', 'data')
-     *   .update({
-     *     transfer_status: 'finished',
-     *   })
-     *   .options({
-     *     return_transfers: true,
-     *   });
-     *
-     * ```
-     *
-     * @param {UpdateTransferGroupsFnInput} [input]
-     * @param {UpdateTransferGroupsFnOptions} [options]
-     * @returns {StreamPromise<UpdateTransferGroupsFnOutput>}
-     *
-     */
-    updateTransferGroups(): UpdateQueryBuilder<UpdateTransferGroupsFnFields, UpdateTransferGroupsFnStringFields, UpdateTransferGroupsFnMetadataFields, UpdateTransferGroupsFnResultFields, UpdateTransferGroupsFnUpdateFields, UpdateTransferGroupsFnOutput>;
-    updateTransferGroups(input: UpdateTransferGroupsFnInput, options?: UpdateTransferGroupsFnOptions): StreamPromise<UpdateTransferGroupsFnOutput>;
-    /**
-     *
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.updateTransfers({
-     *   metadata: {
-     *     example: 'test',
-     *   },
-     *   wallet: WALLETS.validId1.foreign,
-     *   token: 'EUR',
-     *   update: {
-     *     status: 'finished',
-     *   },
-     * });
-     *
-     * expect(result.transfers.length).toEqual(1);
-     * expect(result.transfers[0].status).toEqual('finished');
-     * expect(result.updated).toEqual(true);
-     *
-     * ```
-     *
-     * @param {UpdateTransfersFnInput} [input]
-     * @param {UpdateTransfersFnOptions} [options]
-     * @returns {StreamPromise<UpdateTransfersFnOutput>}
-     *
-     */
-    updateTransfers(): UpdateQueryBuilder<UpdateTransfersFnFields, UpdateTransfersFnStringFields, UpdateTransfersFnMetadataFields, UpdateTransfersFnResultFields, UpdateTransfersFnUpdateFields, UpdateTransfersFnOutput>;
-    updateTransfers(input: UpdateTransfersFnInput, options?: UpdateTransfersFnOptions): StreamPromise<UpdateTransfersFnOutput>;
-    /**
-     * Update Wallet
-     *
-     * ```javascript
-     *
-     * const result = await wapiClient.updateWallet(
-     *   {
-     *     wallet: WALLETS.withEURFunds0.foreign,
-     *     name: 'WT4',
-     *     status: 'disabled',
-     *     metadata: {
-     *       metadata_number: 2,
-     *     },
-     *   },
-     *   {
-     *     return_when_not_updated: true,
-     *     tracking_id: 'mylogId',
-     *     // transaction_id: Transaction.identifier, // created transaction identifier
-     *   },
-     * );
-     * expect(result).toEqual({
-     *   wallet: jasmine.objectContaining({
-     *     id: WALLETS.withEURFunds0.id,
-     *     foreign: WALLETS.withEURFunds0.foreign,
-     *     name: 'WT4',
-     *     metadata: {metadata_number: 2},
-     *     type: WALLETS.withEURFunds0.type,
-     *     status: 'disabled',
-     *     default_allow_negative: false,
-     *     default_allow_positive: true,
-     *     default_dtw_from: '011',
-     *     default_dtw_to: '110',
-     *   }),
-     *   updated: true,
-     * });
-     *
-     * ```
-     *
-     * @param {UpdateWalletFnInput} input
-     * @param {UpdateWalletFnOptions} [options]
-     * @returns {StreamPromise<UpdateWalletFnOutput>}
-     *
-     */
-    updateWallet(input: UpdateWalletFnInput, options?: UpdateWalletFnOptions): StreamPromise<UpdateWalletFnOutput>;
-}
-export declare function createClientWithWS(opts: WapiConnectionOptions, config?: ClientConfig): Client;
+import { WapiConnectionOptions, WapiHttpConnectionOptions, WsClient, HttpClient } from './api';
+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 { AggregateTransfersFnInput, AggregateTransfersFnOutput, AggregateTransfersFnOptions, AggregateTransfersFnFields, AggregateTransfersFnMetadataFields, AggregateTransfersFnStringFields, AggregateTransfersFnGroupFields, CreateAccessTokenFnInput, CreateAccessTokenFnOutput, CreateAccessTokenFnOptions, CreateContractFnInput, CreateContractFnOutput, CreateContractFnOptions, CreateDepositFnInput, CreateDepositFnOutput, CreateDepositFnOptions, CreateExchangeFnInput, CreateExchangeFnOutput, CreateExchangeFnOptions, CreateTokenFnInput, CreateTokenFnOutput, CreateTokenFnOptions, CreateTransferFnInput, CreateTransferFnOutput, CreateTransferFnOptions, CreateTransferGroupFnInput, CreateTransferGroupFnOutput, CreateTransferGroupFnOptions, CreateTransfersFnInput, CreateTransfersFnOutput, CreateTransfersFnOptions, CreateWalletFnInput, CreateWalletFnOutput, CreateWalletFnOptions, CreateWithdrawalFnInput, CreateWithdrawalFnOutput, CreateWithdrawalFnOptions, FindBalancesFnInput, FindBalancesFnOutput, FindBalancesFnOptions, FindBalancesFnFields, FindBalancesFnMetadataFields, FindBalancesFnStringFields, FindBalancesFnResultFields, FindTokensFnInput, FindTokensFnOutput, FindTokensFnOptions, FindTokensFnFields, FindTokensFnMetadataFields, FindTokensFnStringFields, FindTokensFnResultFields, FindTransferGroupsFnInput, FindTransferGroupsFnOutput, FindTransferGroupsFnOptions, FindTransferGroupsFnFields, FindTransferGroupsFnMetadataFields, FindTransferGroupsFnStringFields, FindTransferGroupsFnResultFields, FindTransfersFnInput, FindTransfersFnOutput, FindTransfersFnOptions, FindTransfersFnFields, FindTransfersFnMetadataFields, FindTransfersFnStringFields, FindTransfersFnResultFields, FindWalletsFnInput, FindWalletsFnOutput, FindWalletsFnOptions, FindWalletsFnFields, FindWalletsFnMetadataFields, FindWalletsFnStringFields, FindWalletsFnResultFields, GetBalanceFnInput, GetBalanceFnOutput, GetBalanceFnOptions, GetBalanceHistoryFnInput, GetBalanceHistoryFnOutput, GetBalanceHistoryFnOptions, GetFlagsFnInput, GetFlagsFnOutput, GetFlagsFnOptions, GetStatisticsFnInput, GetStatisticsFnOutput, GetStatisticsFnOptions, GetTokenFnInput, GetTokenFnOutput, GetTokenFnOptions, GetTransferFnInput, GetTransferFnOutput, GetTransferFnOptions, GetTransferGroupFnInput, GetTransferGroupFnOutput, GetTransferGroupFnOptions, GetWalletFnInput, GetWalletFnOutput, GetWalletFnOptions, ImportDataFnInput, ImportDataFnOutput, ImportDataFnOptions, ImportDataFnStreamChunk, ReverseTransferFnInput, ReverseTransferFnOutput, ReverseTransferFnOptions, ReverseTransferGroupFnInput, ReverseTransferGroupFnOutput, ReverseTransferGroupFnOptions, ReverseTransfersFnInput, ReverseTransfersFnOutput, ReverseTransfersFnOptions, ReverseTransfersFnFields, ReverseTransfersFnMetadataFields, ReverseTransfersFnStringFields, ReverseTransfersFnModifications, SetFlagsFnInput, SetFlagsFnOutput, SetFlagsFnOptions, UpdateTokenFnInput, UpdateTokenFnOutput, UpdateTokenFnOptions, UpdateTransferFnInput, UpdateTransferFnOutput, UpdateTransferFnOptions, UpdateTransferGroupFnInput, UpdateTransferGroupFnOutput, UpdateTransferGroupFnOptions, UpdateTransferGroupsFnInput, UpdateTransferGroupsFnOutput, UpdateTransferGroupsFnOptions, UpdateTransferGroupsFnFields, UpdateTransferGroupsFnMetadataFields, UpdateTransferGroupsFnStringFields, UpdateTransferGroupsFnResultFields, UpdateTransferGroupsFnUpdateFields, UpdateTransfersFnInput, UpdateTransfersFnOutput, UpdateTransfersFnOptions, UpdateTransfersFnFields, UpdateTransfersFnMetadataFields, UpdateTransfersFnStringFields, UpdateTransfersFnResultFields, UpdateTransfersFnUpdateFields, UpdateWalletFnInput, UpdateWalletFnOutput, UpdateWalletFnOptions } from './fns';
+export interface ClientConfig {
+    token?: number | string;
+    hooks?: ClientHooks;
+}
+export declare class Client {
+    /**
+     * The BaseClient in use for communication with WAPI Server, manages the actual networking
+     */
+    api: WsClient | HttpClient;
+    /**
+     * Promise resolving to ID upon connection opening
+     */
+    $connect: Promise<ISocketId>;
+    private config;
+    /**
+     * @internal
+     */
+    constructor(_apiClient: WsClient | HttpClient, initialConf?: ClientConfig);
+    /**
+     * Close connection to WAPI instance
+     *
+     * ```javascript
+     *
+     * await wapiClient.close();
+     *
+     * ```
+     */
+    close(): Promise<void>;
+    /**
+     * Returns WAPI client verion
+     *
+     * ```javascript
+     *
+     * wapiClient.version();
+     *
+     * ```
+     */
+    version(): string;
+    /**
+     * Set a hook function
+     *
+     * ```javascript
+     *
+     * wapiClient.setHook('disconnect', () => {
+     *   console.log('disconnected');
+     * });
+     *
+     * ```
+     * @param {ClientHooks} hookName
+     * @param value
+     */
+    setHook(hookName: keyof ClientHooks, value: (input?: unknown) => boolean | void): this;
+    /**
+     * Overwrite client configuration (default token, hooks)
+     *
+     *
+     * ```javascript
+     *
+     * wapiClient.configure({
+     *  token: 'EURO',
+     *  hooks: {
+     *    disconnect: () => {}
+     *  },
+     * });
+     *
+     * ```
+     * @param {ClientConfig} newConf
+     */
+    configure(newConf: Partial<ClientConfig>): this;
+    /**
+     * Get current config key value (token)
+     * ```javascript
+     *
+     * const token = wapiClient.getConfig('token');
+     *
+     * ```
+     */
+    getConfig(key: 'token'): number | string | undefined;
+    /**
+     *
+     * Aggregate Transfers using either a simple filter or queryBuilder
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.aggregateTransfers()
+     *   .where({
+     *     type: 'deposit',
+     *     from_wallet: 'EUR',
+     *     to_wallet: 'house',
+     *   })
+     *   .whereMetadata('example', 'test')
+     *   .sum('to.amount as amount')
+     *   .count()
+     *   .groupBy(
+     *     'metadata.even as type',
+     *     'hour',
+     *     )
+     *   .options({
+     *     tracking_id: 'hello',
+     *     return_all_intervals: {
+     *       start_time: '2021-07-31 11:00:00',
+     *       end_time: '2021-07-31 13:00:00'
+     *     }
+     *   });
+     *
+     * expect(result).toEqual({
+     *   rows: [
+     *     {
+     *       amount: 25,
+     *       count: 5,
+     *       type: 'even',
+     *       hour: '2021-07-31 12',
+     *     },
+     *     {
+     *       amount: 30,
+     *       count: 5,
+     *       type: 'odd',
+     *       hour: '2021-07-31 12',
+     *     },
+     *     {
+     *       amount: null,
+     *       count: 0,
+     *       type: null,
+     *       hour: '2021-07-31 11',
+     *     },
+     *     {
+     *       amount: null,
+     *       count: 0,
+     *       type: null,
+     *       hour: '2021-07-31 13',
+     *     },
+     *   ],
+     *   metadata: {
+     *     aggregators: [
+     *       {
+     *         function: 'sum',
+     *         field: 'to.amount',
+     *         alias: 'amount',
+     *       },
+     *       {
+     *         function: 'count',
+     *         alias: 'count',
+     *       },
+     *     ],
+     *     groups: [
+     *       {
+     *         type: 'metadata_field',
+     *         field: 'even',
+     *         alias: 'type',
+     *       },
+     *       {
+     *         alias: 'hour',
+     *         field: 'hour',
+     *         type: 'period',
+     *       },
+     *     ],
+     *   },
+     * });
+     *
+     * ```
+     *
+     * @param {AggregateTransfersFnInput} [input]
+     * @param {AggregateTransfersFnOptions} [options]
+     * @returns {StreamPromise<AggregateTransfersFnOutput>}
+     *
+     */
+    aggregateTransfers(): AggregateQueryBuilder<AggregateTransfersFnFields, AggregateTransfersFnStringFields, AggregateTransfersFnMetadataFields, AggregateTransfersFnGroupFields, AggregateTransfersFnOutput>;
+    aggregateTransfers(input: AggregateTransfersFnInput, options?: AggregateTransfersFnOptions): StreamPromise<AggregateTransfersFnOutput>;
+    /**
+     *
+     *
+     * ```javascript
+     *
+     * const response = await wapiClient.createAccessToken({
+     *   token: {
+     *     type: 'limited',
+     *     scopes: ['getBalance'],
+     *     filters: {
+     *       wallet_foreign: 'user-1-wallet',
+     *       token_foreign: 'EUR',
+     *     },
+     *     expiresIn: 60,
+     *   }
+     * });
+     *
+     * ```
+     *
+     * @param {CreateAccessTokenFnInput} [input]
+     * @param {CreateAccessTokenFnOptions} [options]
+     * @returns {StreamPromise<CreateAccessTokenFnOutput>}
+     *
+     */
+    createAccessToken(input?: CreateAccessTokenFnInput, options?: CreateAccessTokenFnOptions): StreamPromise<CreateAccessTokenFnOutput>;
+    /**
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createContract({
+     *   foreign: 'MYContract',
+     *   metadata: {
+     *     cool: true,
+     *   },
+     *   value_token: 'EUR',
+     *   value_amount: 100,
+     *   owner: 'oppo',
+     *   buyer: {
+     *     wallet: WALLETS.withEURFunds0.foreign,
+     *     metadata: {
+     *       buying: true,
+     *     },
+     *     amount: 101,
+     *     token: 'EUR',
+     *   },
+     * });
+     *
+     * ```
+     *
+     * @param {CreateContractFnInput} input
+     * @param {CreateContractFnOptions} [options]
+     * @returns {StreamPromise<CreateContractFnOutput>}
+     *
+     */
+    createContract(input: CreateContractFnInput, options?: CreateContractFnOptions): StreamPromise<CreateContractFnOutput>;
+    /**
+     *
+     * Create a deposit transaction into a wallet, by issuing new tokens to the system.
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createDeposit({
+     *   identifier: 'mycustomId',
+     *   token: 'ForeignForToken',
+     *   wallet: 'ForeignForWallet',
+     *   amount: 10.01,
+     *   metadata: {
+     *     customJsonBlob: true,
+     *   },
+     *   status: 'finished',
+     *   // transfer_group: TransferGroup.identifier, // existing transfer group identifier
+     * }, {
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     *   create_wallet_if_not_exists: true,
+     *   return_balance: true,
+     * });
+     *
+     * expect(result).toEqual({
+     *   transfer: jasmine.objectContaining({
+     *     identifier: 'mycustomId',
+     *     token_foreign: 'ForeignForToken',
+     *     to_wallet_foreign: 'ForeignForWallet',
+     *     amount: 10.01,
+     *     metadata: {
+     *       customJsonBlob: true,
+     *     },
+     *     status: 'finished',
+     *     // ... other fields
+     *   }),
+     *   to_balance: jasmine.objectContaining({
+     *     token_foreign: 'ForeignForToken',
+     *     wallet_foreign: 'ForeignForWallet',
+     *     pending_amount: 0,
+     *     finished_amount: 10.01,
+     *     amount: 10.01,
+     *     // ... other fields
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {CreateDepositFnInput} input
+     * @param {CreateDepositFnOptions} [options]
+     * @returns {StreamPromise<CreateDepositFnOutput>}
+     *
+     */
+    createDeposit(input: CreateDepositFnInput, options?: CreateDepositFnOptions): StreamPromise<CreateDepositFnOutput>;
+    /**
+     *
+     * Create an exchange transfer group - change one token in certain amount for another token of certain amount
+     * The transfers are connected and either fail or succeed both
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createExchange({
+     *   identifier: 'exchange',
+     *   from_identifier: 'exchange1',
+     *   from_wallet: WALLETS.withEURFunds0.foreign,
+     *   from_token: 'EUR',
+     *   from_amount: 10,
+     *   to_identifier: 'exchange2',
+     *   to_token: 'USD',
+     *   to_wallet: WALLETS.withUSDFunds0.foreign,
+     *   to_amount: 20,
+     *   status: 'finished',
+     *   metadata: {
+     *     exchangeRate: 2,
+     *   },
+     * }, {
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     * expect(result).toEqual({
+     *   transfer_group: jasmine.objectContaining({
+     *     identifier: 'exchange',
+     *     status: 'closed',
+     *     transfer_status: 'finished',
+     *   }),
+     *   transfers: [
+     *     jasmine.objectContaining({
+     *       status: 'finished',
+     *       amount: 10,
+     *       from_wallet_id: WALLETS.withEURFunds0.id,
+     *       to_wallet_id: WALLETS.withUSDFunds0.id,
+     *       token_id: TOKENS.EUR.id,
+     *       metadata: {
+     *         exchangeRate: 2,
+     *       },
+     *       identifier: 'exchange1',
+     *     }),
+     *     jasmine.objectContaining({
+     *       status: 'finished',
+     *       amount: 20,
+     *       to_wallet_id: WALLETS.withEURFunds0.id,
+     *       from_wallet_id: WALLETS.withUSDFunds0.id,
+     *       token_id: TOKENS.USD.id,
+     *       metadata: {
+     *         exchangeRate: 2,
+     *       },
+     *       identifier: 'exchange2',
+     *     }),
+     *   ],
+     * });
+     *
+     * ```
+     *
+     * @param {CreateExchangeFnInput} input
+     * @param {CreateExchangeFnOptions} [options]
+     * @returns {StreamPromise<CreateExchangeFnOutput>}
+     *
+     */
+    createExchange(input: CreateExchangeFnInput, options?: CreateExchangeFnOptions): StreamPromise<CreateExchangeFnOutput>;
+    /**
+     *
+     * Create a new Token in the system which can then be transferred between wallets
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createToken(
+     *   {
+     *     foreign: 'EURO',
+     *     divisor: 10,
+     *     limit: 10,
+     *     public: true,
+     *     metadata: {
+     *       customMetadata: true,
+     *     },
+     *     // belongs_to: 'EURO-wallet'
+     *   },
+     *   {
+     *     tracking_id: 'mylogId',
+     *     // transaction_id: Transaction.identifier, // created transaction identifier
+     *   },
+     * );
+     *
+     * expect(result).toEqual({
+     *   token: jasmine.objectContaining({
+     *     foreign: 'EURO',
+     *     public: true,
+     *     metadata: {
+     *       customMetadata: true,
+     *     },
+     *   }),
+     *   wallet: jasmine.objectContaining({
+     *     default_allow_positive: false,
+     *     default_allow_negative: true,
+     *     foreign: 'EURO',
+     *     metadata: null,
+     *     type: 'token',
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {CreateTokenFnInput} input
+     * @param {CreateTokenFnOptions} [options]
+     * @returns {StreamPromise<CreateTokenFnOutput>}
+     *
+     */
+    createToken(input: CreateTokenFnInput, options?: CreateTokenFnOptions): StreamPromise<CreateTokenFnOutput>;
+    /**
+     *
+     * Create a transfer of Token amount from one wallet to the other.
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createTransfer({
+     *   identifier: 'mynewtransferid',
+     *   token: 'EUR',
+     *   from_wallet: WALLETS.withEURFunds0.foreign,
+     *   to_wallet: 'foreignForMbyExistingWallet',
+     *   amount: 10.01,
+     *   metadata: {
+     *     customJSON: true,
+     *   },
+     *   type: 'transfer',
+     *   status: 'pending',
+     *   // transfer_group: TransferGroup.identifier,
+     * }, {
+     *   create_to_wallet_if_not_exists: true,
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     *
+     * expect(result).toEqual({
+     *   transfer: jasmine.objectContaining({
+     *     identifier: 'mynewtransferid',
+     *     token_foreign: 'EUR',
+     *     from_wallet_foreign: WALLETS.withEURFunds0.foreign,
+     *     to_wallet_foreign: 'foreignForMbyExistingWallet',
+     *     amount: 10.01,
+     *     metadata: {
+     *       customJSON: true,
+     *     },
+     *     type: 'transfer',
+     *     status: 'pending',
+     *     // ...
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {CreateTransferFnInput} [input]
+     * @param {CreateTransferFnOptions} [options]
+     * @returns {StreamPromise<CreateTransferFnOutput>}
+     *
+     */
+    createTransfer(input?: CreateTransferFnInput, options?: CreateTransferFnOptions): StreamPromise<CreateTransferFnOutput>;
+    /**
+     *
+     * Create a TransferGroup entity to group transfers into a logical or status locked group.
+     * Can include the transfers in the same call or if non 'closed' TransferGroup, add the transfers later.
+     * Can also include child TransferGroups to create a hierarchy
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createTransferGroup({
+     *   identifier: 'mytgIdentifier',
+     *   status: 'closed',
+     *   metadata: {
+     *     customJSON: true,
+     *   },
+     *   transfer_status: 'finished',
+     *   // transfer_group: ParentTransferGroup.identifier,
+     *   children: [
+     *     {
+     *       identifier: 'txIdentifier',
+     *       from_wallet: WALLETS.withEURFunds0.foreign,
+     *       to_wallet: 'newWalletForeign',
+     *       token: 'EUR',
+     *       amount: 10,
+     *       type: 'transfer',
+     *       latest_control_hash: WALLETS.withEURFunds0.latest_control_hash,
+     *     },
+     *     {
+     *       identifier: 'childTgTransferId',
+     *       from_wallet: 'newWalletForeign',
+     *       to_wallet: WALLETS.withEURFunds0.foreign,
+     *       token: 'EUR',
+     *       amount: 9,
+     *       type: 'transfer',
+     *       latest_control_hash: null, // not needed because we just transferred money there,
+     *     },
+     *   ],
+     * }, {
+     *   validate_final_balance_only: true,
+     *   create_to_wallet_if_not_exists: true,
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     *
+     * expect(result).toEqual(jasmine.objectContaining({
+     *   transfer_group: jasmine.objectContaining({
+     *     identifier: 'mytgIdentifier',
+     *     status: 'closed',
+     *     metadata: {
+     *       customJSON: true,
+     *     },
+     *     transfer_status: 'finished',
+     *   }),
+     *   transfers: [
+     *     jasmine.objectContaining({
+     *       identifier: 'txIdentifier',
+     *       from_wallet_foreign: WALLETS.withEURFunds0.foreign,
+     *       to_wallet_foreign: 'newWalletForeign',
+     *       token_foreign: 'EUR',
+     *       amount: 10,
+     *       type: 'transfer',
+     *     }),
+     *     jasmine.objectContaining({
+     *       identifier: 'childTgTransferId',
+     *       from_wallet_foreign: 'newWalletForeign',
+     *       to_wallet_foreign: WALLETS.withEURFunds0.foreign,
+     *       token_foreign: 'EUR',
+     *       amount: 9,
+     *       type: 'transfer',
+     *     }),
+     *   ],
+     * }));
+     *
+     *
+     * ```
+     *
+     * @param {CreateTransferGroupFnInput} input
+     * @param {CreateTransferGroupFnOptions} [options]
+     * @returns {StreamPromise<CreateTransferGroupFnOutput>}
+     *
+     */
+    createTransferGroup(input: CreateTransferGroupFnInput, options?: CreateTransferGroupFnOptions): StreamPromise<CreateTransferGroupFnOutput>;
+    /**
+     *
+     * Create multiple transfers with one call. Transfers are created in a transaction so it either succeeds or fails as one.
+     * Will respect internal balance transfers to avoid latest_control_hash
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createTransfers({
+     *   transfers: [{
+     *     type: 'deposit',
+     *     wallet: WALLETS.validForeign2,
+     *     token: 'EURO',
+     *     amount: 10.01,
+     *   }, {
+     *     from_wallet: WALLETS.validForeign2,
+     *     to_wallet: 'newWalletForeignMby',
+     *     token: 'EURO',
+     *     amount: 10.01,
+     *     latest_control_hash: null, // not required as we just transferred funds
+     *   }, {
+     *     type: 'withdrawal',
+     *     wallet: 'newWalletForeignMby',
+     *     token: 'EURO',
+     *     amount: 10.01,
+     *     latest_control_hash: null, // not required as we just transferred funds
+     *   }],
+     * }, {
+     *   create_to_wallet_if_not_exists: true,
+     *   return_from_balance: true,
+     *   return_to_balance: true,
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     *
+     * expect(result).toEqual(jasmine.objectContaining({
+     *   transfers: [
+     *     jasmine.objectContaining({
+     *       type: 'deposit',
+     *       token_foreign: 'EURO',
+     *       to_wallet_foreign: WALLETS.validForeign2,
+     *       amount: 10.01,
+     *     }),
+     *     jasmine.objectContaining({
+     *       type: 'transfer',
+     *       token_foreign: 'EURO',
+     *       from_wallet_foreign: WALLETS.validForeign2,
+     *       to_wallet_foreign: 'newWalletForeignMby',
+     *       amount: 10.01,
+     *     }),
+     *     jasmine.objectContaining({
+     *       type: 'withdrawal',
+     *       token_foreign: 'EURO',
+     *       from_wallet_foreign: 'newWalletForeignMby',
+     *       amount: 10.01,
+     *     }),
+     *   ],
+     *   // We are doing a 0 sum with 3 transactions so everything is back to 0
+     *   from_balances: [
+     *     jasmine.objectContaining({
+     *       token_foreign: 'EURO',
+     *       wallet_foreign: 'EURO',
+     *       amount: 0,
+     *     }),
+     *     jasmine.objectContaining({
+     *       token_foreign: 'EURO',
+     *       wallet_foreign: WALLETS.validForeign2,
+     *       amount: 0,
+     *     }),
+     *     jasmine.objectContaining({
+     *       token_foreign: 'EURO',
+     *       wallet_foreign: 'newWalletForeignMby',
+     *       amount: 0,
+     *     }),
+     *   ],
+     *   to_balances: [
+     *     jasmine.objectContaining({
+     *       token_foreign: 'EURO',
+     *       wallet_foreign: WALLETS.validForeign2,
+     *       amount: 0,
+     *     }),
+     *     jasmine.objectContaining({
+     *       token_foreign: 'EURO',
+     *       wallet_foreign: 'newWalletForeignMby',
+     *       amount: 0,
+     *     }),
+     *     jasmine.objectContaining({
+     *       token_foreign: 'EURO',
+     *       wallet_foreign: 'EURO',
+     *       amount: 0,
+     *     }),
+     *   ],
+     * }));
+     *
+     *
+     * ```
+     *
+     * @param {CreateTransfersFnInput} input
+     * @param {CreateTransfersFnOptions} [options]
+     * @returns {StreamPromise<CreateTransfersFnOutput>}
+     *
+     */
+    createTransfers(input: CreateTransfersFnInput, options?: CreateTransfersFnOptions): StreamPromise<CreateTransfersFnOutput>;
+    /**
+     *
+     * Create a Wallet entity which can then transfer amounts of Tokens.
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createWallet({
+     *   foreign: 'test-wallet-2',
+     *   name: 'Irrelevant',
+     *   metadata: {
+     *     awesome: true,
+     *     invalid: false,
+     *   },
+     * }, {
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     *
+     * expect(result).toEqual({
+     *   wallet: jasmine.objectContaining({
+     *     foreign: 'test-wallet-2',
+     *     name: 'Irrelevant',
+     *     metadata: {
+     *       awesome: true,
+     *       invalid: false,
+     *     },
+     *   }),
+     * });
+     *
+     *
+     * ```
+     *
+     * @param {CreateWalletFnInput} input
+     * @param {CreateWalletFnOptions} [options]
+     * @returns {StreamPromise<CreateWalletFnOutput>}
+     *
+     */
+    createWallet(input: CreateWalletFnInput, options?: CreateWalletFnOptions): StreamPromise<CreateWalletFnOutput>;
+    /**
+     *
+     * Create a transfer withdrawing funds from a Wallet.
+     * Will default to transferring funds to Token default Wallet.
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.createWithdrawal({
+     *   identifier: 'mycustomId',
+     *   token: 'ForeignForToken',
+     *   wallet: 'ForeignForWallet',
+     *   amount: 10.01,
+     *   metadata: {
+     *     customJsonBlob: true,
+     *   },
+     *   status: 'finished',
+     *   latest_control_hash: null,
+     *   // transfer_group: TransferGroup.identifier, // existing transfer group identifier
+     * }, {
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     *   return_balance: true,
+     * });
+     *
+     * expect(result).toEqual({
+     *   transfer: jasmine.objectContaining({
+     *     identifier: 'mycustomId',
+     *     token_foreign: 'ForeignForToken',
+     *     from_wallet_foreign: 'ForeignForWallet',
+     *     amount: 10.01,
+     *     metadata: {
+     *       customJsonBlob: true,
+     *     },
+     *     status: 'finished',
+     *     // ... other fields
+     *   }),
+     *   from_balance: jasmine.objectContaining({
+     *     token_foreign: 'ForeignForToken',
+     *     wallet_foreign: 'ForeignForWallet',
+     *     pending_amount: 0,
+     *     finished_amount: 89.99,
+     *     amount: 89.99,
+     *     // ... other fields
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {CreateWithdrawalFnInput} input
+     * @param {CreateWithdrawalFnOptions} [options]
+     * @returns {StreamPromise<CreateWithdrawalFnOutput>}
+     *
+     */
+    createWithdrawal(input: CreateWithdrawalFnInput, options?: CreateWithdrawalFnOptions): StreamPromise<CreateWithdrawalFnOutput>;
+    /**
+     *
+     * Search for Balances using either a simple filter or queryBuilder
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.findBalances()
+     *   .where({
+     *     wallet: WALLETS.validId0,
+     *   })
+     *   .orWhere('amount', '>', 100)
+     *   .orWhere({
+     *     wallet: WALLETS.validId1,
+     *     token: 'USD',
+     *   })
+     *   .orWhere(builder => {
+     *     builder.where('updated_at', '<', '2020-01-01')
+     *       .where('amount', '<', -1000000);
+     *   })
+     *   .limit(5)
+     *   .offset(0)
+     *   .orderBy('amount', 'desc')
+     *   .options({
+     *     tracking_id: 'hello',
+     *     return_metadata_total: true,
+     *   });
+     *
+     * ```
+     *
+     * @param {FindBalancesFnInput} [input]
+     * @param {FindBalancesFnOptions} [options]
+     * @returns {StreamPromise<FindBalancesFnOutput>}
+     *
+     */
+    findBalances(): QueryBuilder<FindBalancesFnFields, FindBalancesFnStringFields, FindBalancesFnMetadataFields, FindBalancesFnResultFields, FindBalancesFnOptions, FindBalancesFnOutput>;
+    findBalances(input: FindBalancesFnInput, options?: FindBalancesFnOptions): StreamPromise<FindBalancesFnOutput>;
+    /**
+     *
+     * Search for Tokens using either a simple filter or queryBuilder
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.findTokens()
+     *   .where({
+     *     metadata: {
+     *       even: true,
+     *       example: 'test',
+     *     },
+     *   })
+     *   .orWhere({
+     *     foreign: 'token-example1',
+     *   })
+     *   .limit(5)
+     *   .offset(0)
+     *   .orderBy(['foreign', {column: 'id', order: 'desc'}])
+     *   .options({
+     *     tracking_id: 'hello',
+     *     return_metadata_total: true,
+     *   });
+     *
+     * ```
+     *
+     * @param {FindTokensFnInput} [input]
+     * @param {FindTokensFnOptions} [options]
+     * @returns {StreamPromise<FindTokensFnOutput>}
+     *
+     */
+    findTokens(): QueryBuilder<FindTokensFnFields, FindTokensFnStringFields, FindTokensFnMetadataFields, FindTokensFnResultFields, FindTokensFnOptions, FindTokensFnOutput>;
+    findTokens(input: FindTokensFnInput, options?: FindTokensFnOptions): StreamPromise<FindTokensFnOutput>;
+    /**
+     *
+     * Search for TransferGroups using either a simple filter or queryBuilder
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.findTransferGroups()
+     *   .where({
+     *     metadata: {
+     *       even: true,
+     *       example: 'test',
+     *     },
+     *   })
+     *   .orWhere({
+     *     identifier: 'reverser-example',
+     *   })
+     *   .orWhere(builder => {
+     *     builder.where({
+     *       metadata: {
+     *         kak: true,
+     *       },
+     *     })
+     *       .where('created_at', '>', '2020-01-01');
+     *   })
+     *   .limit(5)
+     *   .offset(0)
+     *   .orderBy('id', 'desc')
+     *   .select('id', 'type', 'identifier')
+     *   .options({
+     *     tracking_id: 'hello',
+     *     return_metadata_total: true,
+     *   });
+     *
+     * ```
+     *
+     * @param {FindTransferGroupsFnInput} [input]
+     * @param {FindTransferGroupsFnOptions} [options]
+     * @returns {StreamPromise<FindTransferGroupsFnOutput>}
+     *
+     */
+    findTransferGroups(): QueryBuilder<FindTransferGroupsFnFields, FindTransferGroupsFnStringFields, FindTransferGroupsFnMetadataFields, FindTransferGroupsFnResultFields, FindTransferGroupsFnOptions, FindTransferGroupsFnOutput>;
+    findTransferGroups(input: FindTransferGroupsFnInput, options?: FindTransferGroupsFnOptions): StreamPromise<FindTransferGroupsFnOutput>;
+    /**
+     *
+     * Search for Transfers using either a simple filter or queryBuilder
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.findTransfers()
+     *   .where({
+     *     metadata: {
+     *       example: true,
+     *     },
+     *   })
+     *   .where('id', '>', 1)
+     *   .where(builder => {
+     *     builder.where('status', 'finished')
+     *       .orWhere('type', 'deposit');
+     *   })
+     *   .limit(5)
+     *   .offset(0)
+     *   .orderBy(['token_id', {column: 'id', order: 'desc'}])
+     *   .select('id', 'type', 'from_wallet_foreign', 'to_wallet_foreign')
+     *   .options({
+     *     tracking_id: 'hello',
+     *   });
+     *
+     * ```
+     *
+     * @param {FindTransfersFnInput} [input]
+     * @param {FindTransfersFnOptions} [options]
+     * @returns {StreamPromise<FindTransfersFnOutput>}
+     *
+     */
+    findTransfers(): QueryBuilder<FindTransfersFnFields, FindTransfersFnStringFields, FindTransfersFnMetadataFields, FindTransfersFnResultFields, FindTransfersFnOptions, FindTransfersFnOutput>;
+    findTransfers(input: FindTransfersFnInput, options?: FindTransfersFnOptions): StreamPromise<FindTransfersFnOutput>;
+    /**
+     *
+     * Search for Wallets using either a simple filter or queryBuilder
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.findWallets()
+     *   .where({
+     *     metadata: {
+     *       general: true,
+     *     },
+     *   })
+     *   .where('id', '>', 1)
+     *   .where(builder => {
+     *     builder
+     *       .whereMetadata('tost', 10)
+     *       .orWhereMetadata('test', 1);
+     *   })
+     *   .limit(5)
+     *   .offset(0)
+     *   .orderBy(['status', {column: 'id', order: 'desc'}])
+     *   .select('id')
+     *   .options({
+     *     tracking_id: 'hello',
+     *   });
+     *
+     * ```
+     *
+     * @param {FindWalletsFnInput} [input]
+     * @param {FindWalletsFnOptions} [options]
+     * @returns {StreamPromise<FindWalletsFnOutput>}
+     *
+     */
+    findWallets(): QueryBuilder<FindWalletsFnFields, FindWalletsFnStringFields, FindWalletsFnMetadataFields, FindWalletsFnResultFields, FindWalletsFnOptions, FindWalletsFnOutput>;
+    findWallets(input: FindWalletsFnInput, options?: FindWalletsFnOptions): StreamPromise<FindWalletsFnOutput>;
+    /**
+     *
+     * Get a specific token/wallet balance
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.getBalance({
+     *   wallet: 'myMbyExistingWallet',
+     *   token: 'MBYTOKEN',
+     *   datetime: '2020-01-01',
+     * }, {
+     *   create_wallet_if_not_exists: true,
+     *   create_token_if_not_exists: true,
+     *   create_if_not_exists: true,
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     *
+     * expect(result).toEqual({
+     *   balance: jasmine.objectContaining({
+     *     wallet_foreign: 'myMbyExistingWallet',
+     *     token_foreign: 'MBYTOKEN',
+     *     pending_amount: 0,
+     *     finished_amount: 0,
+     *     amount: 0,
+     *     latest_control_hash: null,
+     *     available_balance: 0,
+     *     // ...
+     *   }),
+     * });
+     *
+     *
+     * ```
+     *
+     * @param {GetBalanceFnInput} input
+     * @param {GetBalanceFnOptions} [options]
+     * @returns {StreamPromise<GetBalanceFnOutput>}
+     *
+     */
+    getBalance(input: GetBalanceFnInput, options?: GetBalanceFnOptions): StreamPromise<GetBalanceFnOutput>;
+    /**
+     *
+     * Get a list of changes to token/wallet balance
+     *
+     * ```javascript
+     *
+     * // setup
+     * const deposit = await wapiClient.createDeposit({
+     *   wallet: 'newWallet',
+     *   amount: 10,
+     *   status: 'pending',
+     *   identifier: 'depositUSD',
+     *   token: 'USD',
+     * }, {
+     *   create_wallet_if_not_exists: true,
+     * });
+     * const updatedTransfer = await wapiClient.updateTransfer({
+     *   transfer: 'depositUSD',
+     *   status: 'finished',
+     * });
+     *
+     * const result = await wapiClient.getBalanceHistory({
+     *   wallet: 'newWallet',
+     *   token: 'USD',
+     * }, {
+     *   create_token_if_not_exists: true,
+     *   create_wallet_if_not_exists: true,
+     *   limit: 5,
+     *   select: [
+     *     'transfer_identifier',
+     *     'pending_amount',
+     *     'finished_amount',
+     *     'pending_amount_from',
+     *     'pending_amount_to',
+     *     'amount',
+     *     // 'balance_id',
+     *     // 'transfer_id',
+     *     // 'transfer_control_hash',
+     *     // 'transfer_from_wallet_id',
+     *     // 'transfer_from_wallet_foreign',
+     *     // 'transfer_to_wallet_id',
+     *     // 'transfer_to_wallet_foreign',
+     *     // 'transfer_amount',
+     *     // 'transfer_type',
+     *     // 'transfer_status',
+     *     // 'transfer_force',
+     *     // 'transfer_created_at',
+     *     // 'transfer_updated_at',
+     *     // 'transfer_metadata',
+     *     // 'transfer_transfer_group_id',
+     *     // 'transfer_transfer_group_identifier',
+     *     // 'transfer_reverses_id',
+     *     // 'transfer_reverses_identifier',
+     *     // 'transfer_status_finalized_at',
+     *     // 'token_id',
+     *     // 'token_foreign',
+     *     // 'wallet_id',
+     *     // 'wallet_foreign',
+     *     // 'latest_control_hash',
+     *     // 'updated_at',
+     *   ],
+     *   offset: 0,
+     *   order: 'desc',
+     *   return_metadata_total: true,
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     * expect(result).toEqual({
+     *   balances: [
+     *     {
+     *       transfer_identifier: 'depositUSD',
+     *       pending_amount: 0,
+     *       finished_amount: 10,
+     *       pending_amount_to: 0,
+     *       pending_amount_from: 0,
+     *       amount: 10,
+     *     },
+     *     {
+     *       transfer_identifier: 'depositUSD',
+     *       pending_amount: 10,
+     *       finished_amount: 0,
+     *       pending_amount_to: 10,
+     *       pending_amount_from: 0,
+     *       amount: 10,
+     *     },
+     *   ],
+     *   metadata: {
+     *     limit: 5,
+     *     offset: 0,
+     *     total: 2,
+     *     more_rows: false,
+     *   },
+     * });
+     *
+     * ```
+     *
+     * @param {GetBalanceHistoryFnInput} input
+     * @param {GetBalanceHistoryFnOptions} [options]
+     * @returns {StreamPromise<GetBalanceHistoryFnOutput>}
+     *
+     */
+    getBalanceHistory(input: GetBalanceHistoryFnInput, options?: GetBalanceHistoryFnOptions): StreamPromise<GetBalanceHistoryFnOutput>;
+    /**
+     *
+     * Retrieve the current state of configurable Flags for your WAPI instance
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.getFlags();
+     * expect(result.flags).toEqual({
+     *   production: true,
+     *   allow_timestamps: false,
+     * });
+     *
+     * ```
+     *
+     * @param {GetFlagsFnInput} [input]
+     * @param {GetFlagsFnOptions} [options]
+     * @returns {StreamPromise<GetFlagsFnOutput>}
+     *
+     */
+    getFlags(input?: GetFlagsFnInput, options?: GetFlagsFnOptions): StreamPromise<GetFlagsFnOutput>;
+    /**
+     *
+     * Get aggregated statistics about WAPI entities
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.getStatistics({
+     *   model: 'Transfer',
+     *   aggregator: 'count',
+     *   groups: [{
+     *     type: 'period',
+     *     field: {
+     *       period: 'month',
+     *       timezone: 'Europe/Tallinn',
+     *     },
+     *   }],
+     *   filter: {
+     *     end_time: (new Date(`${new Date().getFullYear() + 1}-01-01`)).toISOString(),
+     *     start_time: (new Date(`${new Date().getFullYear()}-01-01`)).toISOString(),
+     *   },
+     * }, {
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     *
+     * expect(result).toEqual({
+     *   rows: [
+     *     {
+     *       aggregate: 3,
+     *       period: `${new Date().getFullYear()}-${(new Date().getMonth() + 1 + '').padStart(2, '0')}`,
+     *     },
+     *   ],
+     * });
+     *
+     * ```
+     *
+     * @param {GetStatisticsFnInput} [input]
+     * @param {GetStatisticsFnOptions} [options]
+     * @returns {StreamPromise<GetStatisticsFnOutput>}
+     *
+     */
+    getStatistics(input?: GetStatisticsFnInput, options?: GetStatisticsFnOptions): StreamPromise<GetStatisticsFnOutput>;
+    /**
+     *
+     * Get information about token
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.getToken({
+     *   foreign: 'EURO',
+     * }, {
+     *   create_if_not_exists: true,
+     *   // return_only_id: true, // for example purposes we want more than id
+     *   ignore_cache: true,
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     *
+     * expect(result).toEqual({
+     *   token: jasmine.objectContaining({
+     *     foreign: 'EURO',
+     *     metadata: null,
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {GetTokenFnInput} [input]
+     * @param {GetTokenFnOptions} [options]
+     * @returns {StreamPromise<GetTokenFnOutput>}
+     *
+     */
+    getToken(input?: GetTokenFnInput, options?: GetTokenFnOptions): StreamPromise<GetTokenFnOutput>;
+    /**
+     *
+     * Get information about a specific transfer
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.getTransfer({
+     *   transfer: 'get-transfer-test',
+     * }, {
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     * expect(result).toEqual({
+     *   transfer: jasmine.objectContaining({
+     *     identifier: 'get-transfer-test',
+     *     // ...
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {GetTransferFnInput} input
+     * @param {GetTransferFnOptions} [options]
+     * @returns {StreamPromise<GetTransferFnOutput>}
+     *
+     */
+    getTransfer(input: GetTransferFnInput, options?: GetTransferFnOptions): StreamPromise<GetTransferFnOutput>;
+    /**
+     *
+     * Get TransferGroup information
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.getTransferGroup({
+     *   transfer_group: 'customIdentifier',
+     * }, {
+     *   create_if_not_exists: true,
+     *   // return_only_id: true, // example requires more than just ID
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     * expect(result).toEqual({
+     *   transfer_group: jasmine.objectContaining({
+     *     identifier: 'customIdentifier',
+     *     metadata: null,
+     *     status: 'open',
+     *     transfer_status: 'pending',
+     *     status_finalized_at: null,
+     *     transfer_status_finalized_at: null,
+     *     reverses_id: null,
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {GetTransferGroupFnInput} input
+     * @param {GetTransferGroupFnOptions} [options]
+     * @returns {StreamPromise<GetTransferGroupFnOutput>}
+     *
+     */
+    getTransferGroup(input: GetTransferGroupFnInput, options?: GetTransferGroupFnOptions): StreamPromise<GetTransferGroupFnOutput>;
+    /**
+     *
+     * Get information about wallet
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.getWallet({
+     *   wallet: WALLETS.withEURFunds0.foreign,
+     * }, {
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     *   ignore_cache: true,
+     *   create_if_not_exists: true,
+     *   return_only_id: false,
+     * });
+     * expect(result).toEqual({
+     *   wallet: jasmine.objectContaining({
+     *     foreign: WALLETS.withEURFunds0.foreign,
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {GetWalletFnInput} input
+     * @param {GetWalletFnOptions} [options]
+     * @returns {StreamPromise<GetWalletFnOutput>}
+     *
+     */
+    getWallet(input: GetWalletFnInput, options?: GetWalletFnOptions): StreamPromise<GetWalletFnOutput>;
+    /**
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.importData().input(async (stream) => {
+     *   const fileStream = createReadStream(join(__dirname, '../lib/short-import.txt'));
+     *
+     *   const rl = createInterface({
+     *     input: fileStream,
+     *     crlfDelay: Infinity
+     *   });
+     *   for await (const line of rl) {
+     *     // Each line in input.txt will be successively available here as `line`.
+     *     if (!line) {
+     *       continue;
+     *     }
+     *     const obj = JSON.parse(line);
+     *     stream.write(obj);
+     *   }
+     *   stream.end();
+     * });
+     *
+     * ```
+     *
+     * @param {ImportDataFnInput} [input]
+     * @param {ImportDataFnOptions} [options]
+     * @returns {StreamPromise<ImportDataFnOutput>}
+     *
+     */
+    importData(options?: ImportDataFnOptions): StreamPromiseInput<ImportDataFnOutput, ImportDataFnStreamChunk>;
+    importData(input: ImportDataFnInput, options?: ImportDataFnOptions): StreamPromise<ImportDataFnOutput>;
+    /**
+     *
+     * Reverse a transfer of value between two wallets
+     * will cancel pending transfers and create opposite transfers for finished ones.
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.reverseTransfer({
+     *   transfer: 'MYDEPOSIT',
+     *   status: 'finished',
+     *   identifier: 'MYREVERSEDEPOSIT',
+     *   force: true,
+     *   // metadata: {},
+     *   metadata: {
+     *     extraCustomJSON: true,
+     *   },
+     * }, {
+     *   reverse_deposit: true,
+     *   reverse_withdrawal: true,
+     *   return_to_balance: true,
+     *   return_from_balance: true,
+     *   metadata_action: 'extend',
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     * expect(result).toEqual({
+     *   transfer: jasmine.objectContaining({
+     *     identifier: 'MYREVERSEDEPOSIT',
+     *     amount: 10.01,
+     *     type: 'withdrawal',
+     *     status: 'finished',
+     *     force: true,
+     *     metadata: {
+     *       customJSON: true,
+     *       extraCustomJSON: true,
+     *     },
+     *     transfer_group_id: null,
+     *     reverses_id: DEPOSIT.id,
+     *     from_wallet_foreign: DEPOSIT.to_wallet_foreign,
+     *     to_wallet_foreign: DEPOSIT.from_wallet_foreign,
+     *     token_foreign: DEPOSIT.token_foreign,
+     *     // ...
+     *   }),
+     *   to_balance: jasmine.objectContaining({
+     *     token_foreign: DEPOSIT.token_foreign,
+     *     wallet_foreign: DEPOSIT.from_wallet_foreign,
+     *     // ...
+     *   }),
+     *   from_balance: jasmine.objectContaining({
+     *     token_foreign: DEPOSIT.token_foreign,
+     *     wallet_foreign: DEPOSIT.to_wallet_foreign,
+     *     // ...
+     *   }),
+     * });
+     *
+     * ```
+     *
+     * @param {ReverseTransferFnInput} input
+     * @param {ReverseTransferFnOptions} [options]
+     * @returns {StreamPromise<ReverseTransferFnOutput>}
+     *
+     */
+    reverseTransfer(input: ReverseTransferFnInput, options?: ReverseTransferFnOptions): StreamPromise<ReverseTransferFnOutput>;
+    /**
+     *
+     * Similar to reverseTransfer will reverse value transfers, however it will reverse the whole
+     * group with its children by creating a new group with opposite transfers.
+     *
+     * ```javascript
+     *
+     * // Should succeed if flag is set
+     * const result = await wapiClient.reverseTransferGroup({
+     *   transfer_group: 'myCustom',
+     *   identifier: 'myCustomReverse',
+     *   metadata: {
+     *     extraCustomJSON: true,
+     *   },
+     *   transfer_status: 'finished',
+     * }, {
+     *   validate_final_balance_only: true,
+     *   reverse_deposit: true,
+     *   reverse_withdrawal: true,
+     *   return_transfers: true,
+     *   metadata_action: 'extend',
+     *   transfer_metadata_action: 'extend',
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     *
+     * expect(result).toEqual({
+     *   transfer_group: jasmine.objectContaining({
+     *     identifier: 'myCustomReverse',
+     *     status: 'closed',
+     *     metadata: {
+     *       customJSON: true,
+     *       extraCustomJSON: true,
+     *     },
+     *     transfer_status: 'finished',
+     *   }),
+     *   transfers: [
+     *     jasmine.objectContaining({
+     *       from_wallet_foreign: 'myWallet2',
+     *       to_wallet_foreign: 'myWallet1',
+     *       amount: 8,
+     *       type: 'transfer',
+     *       status: 'finished',
+     *       token_foreign: 'EUR',
+     *     }),
+     *     jasmine.objectContaining({
+     *       from_wallet_foreign: 'myWallet1',
+     *       to_wallet_foreign: 'EUR',
+     *       amount: 10,
+     *       type: 'withdrawal',
+     *       status: 'finished',
+     *       token_foreign: 'EUR',
+     *     }),
+     *   ],
+     * });
+     *
+     * ```
+     *
+     * @param {ReverseTransferGroupFnInput} input
+     * @param {ReverseTransferGroupFnOptions} [options]
+     * @returns {StreamPromise<ReverseTransferGroupFnOutput>}
+     *
+     */
+    reverseTransferGroup(input: ReverseTransferGroupFnInput, options?: ReverseTransferGroupFnOptions): StreamPromise<ReverseTransferGroupFnOutput>;
+    /**
+     *
+     *
+     * ```javascript
+     *
+     * const [[finishedTransfer1], [finishedTransfer2]] = await Promise.all([
+     *   TEST.knex('transfers').insert({
+     *     identifier: getTxIdSync(),
+     *     auto_hash: true,
+     *     amount: toNumberInput(10.12),
+     *     status: 'finished',
+     *     metadata: {
+     *       example: 'test'
+     *     },
+     *     from_wallet_id: WALLETS.withEURFunds0.id,
+     *     to_wallet_id: WALLETS.validId1,
+     *     token_id: TOKENS.EUR.id,
+     *   }).returning('*'),
+     *   TEST.knex('transfers').insert({
+     *     identifier: getTxIdSync(),
+     *     auto_hash: true,
+     *     amount: toNumberInput(10.12),
+     *     status: 'finished',
+     *     metadata: {
+     *       example: 'test'
+     *     },
+     *     from_wallet_id: WALLETS.withEURFunds0.id,
+     *     to_wallet_id: WALLETS.validId1,
+     *     token_id: TOKENS.EUR.id,
+     *   }).returning('*'),
+     * ]);
+     *
+     * const result = await wapiClient.reverseTransfers({
+     *   metadata: {
+     *     example: 'test'
+     *   },
+     * });
+     *
+     * const { transfers } = result;
+     * expect(transfers.length).toEqual(2);
+     *
+     * expect(transfers[0].identifier).not.toEqual(finishedTransfer1.identifier);
+     * expect(transfers[0].amount).toEqual(formatNumber(finishedTransfer1.amount));
+     * expect(transfers[0].from_wallet_id).toEqual(finishedTransfer1.to_wallet_id);
+     * expect(transfers[0].to_wallet_id).toEqual(finishedTransfer1.from_wallet_id);
+     *
+     * expect(transfers[1].identifier).not.toEqual(finishedTransfer2.identifier);
+     * expect(transfers[1].amount).toEqual(formatNumber(finishedTransfer2.amount));
+     * expect(transfers[1].from_wallet_id).toEqual(finishedTransfer2.to_wallet_id);
+     * expect(transfers[1].to_wallet_id).toEqual(finishedTransfer2.from_wallet_id);
+     *
+     * ```
+     *
+     * @param {ReverseTransfersFnInput} [input]
+     * @param {ReverseTransfersFnOptions} [options]
+     * @returns {StreamPromise<ReverseTransfersFnOutput>}
+     *
+     */
+    reverseTransfers(): ReverseQueryBuilder<ReverseTransfersFnFields, ReverseTransfersFnStringFields, ReverseTransfersFnMetadataFields, ReverseTransfersFnModifications, ReverseTransfersFnOutput>;
+    reverseTransfers(input: ReverseTransfersFnInput, options?: ReverseTransfersFnOptions): StreamPromise<ReverseTransfersFnOutput>;
+    /**
+     *
+     * Configure WAPI instance Flags
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.setFlags({
+     *   production: false,
+     *   allow_timestamps: true,
+     * }, {
+     *   tracking_id: 'mylog',
+     * });
+     * expect(result).toEqual({
+     *   flags: {
+     *     production: false,
+     *     allow_timestamps: true,
+     *   },
+     *   message: 'flag updated, reconnect to apply',
+     * });
+     *
+     * ```
+     *
+     * @param {SetFlagsFnInput} input
+     * @param {SetFlagsFnOptions} [options]
+     * @returns {StreamPromise<SetFlagsFnOutput>}
+     *
+     */
+    setFlags(input: SetFlagsFnInput, options?: SetFlagsFnOptions): StreamPromise<SetFlagsFnOutput>;
+    /**
+     * Update token object
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.updateToken(
+     *   {
+     *     token: TOKENS.EUR.foreign,
+     *     public: false,
+     *     metadata: {
+     *       metadata_field: 2,
+     *     },
+     *     status: 'disabled',
+     *   },
+     *   {
+     *     return_when_not_updated: true,
+     *     tracking_id: 'mylogId',
+     *     // transaction_id: Transaction.identifier, // created transaction identifier
+     *   },
+     * );
+     * expect(result).toEqual({
+     *   token: jasmine.objectContaining({
+     *     belongs_to: TOKENS.EUR.belongs_to,
+     *     divisor: TOKENS.EUR.divisor,
+     *     id: TOKENS.EUR.id,
+     *     limit: TOKENS.EUR.limit,
+     *     metadata: {
+     *       metadata_field: 2,
+     *     },
+     *     type: TOKENS.EUR.type,
+     *     foreign: TOKENS.EUR.foreign,
+     *     public: false,
+     *     status: 'disabled',
+     *   }),
+     *   updated: true,
+     * });
+     *
+     * ```
+     *
+     * @param {UpdateTokenFnInput} input
+     * @param {UpdateTokenFnOptions} [options]
+     * @returns {StreamPromise<UpdateTokenFnOutput>}
+     *
+     */
+    updateToken(input: UpdateTokenFnInput, options?: UpdateTokenFnOptions): StreamPromise<UpdateTokenFnOutput>;
+    /**
+     *
+     * Update the status of a Transfer (pending to finished or cancelled)
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.updateTransfer({
+     *   transfer: 'myPendingDeposit',
+     *   status: 'cancelled',
+     *   metadata: {
+     *     meta: 'new',
+     *     was: true,
+     *   },
+     * }, {
+     *   return_from_balance: true,
+     *   return_to_balance: true,
+     *   return_when_not_updated: true,
+     *   metadata_action: 'extend',
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     * expect(result).toEqual({
+     *   transfer: jasmine.objectContaining({
+     *     identifier: 'myPendingDeposit',
+     *     amount: 10.01,
+     *     type: 'deposit',
+     *     status: 'cancelled',
+     *     transfer_group_id: null,
+     *     reverses_id: null,
+     *     from_wallet_foreign: 'EURO',
+     *     to_wallet_foreign: 'myWallet',
+     *     token_foreign: 'EURO',
+     *     metadata: {
+     *       meta: 'new',
+     *       is: true,
+     *       was: true,
+     *     }
+     *   }),
+     *   to_balance: jasmine.objectContaining({
+     *     token_foreign: 'EURO',
+     *     wallet_foreign: 'myWallet',
+     *     pending_amount: 0,
+     *     finished_amount: 0,
+     *     amount: 0,
+     *   }),
+     *   from_balance: jasmine.objectContaining({
+     *     token_foreign: 'EURO',
+     *     wallet_foreign: 'EURO',
+     *     pending_amount: 0,
+     *     finished_amount: 0,
+     *     amount: 0,
+     *   }),
+     *   updated: true,
+     * });
+     *
+     * ```
+     *
+     * @param {UpdateTransferFnInput} input
+     * @param {UpdateTransferFnOptions} [options]
+     * @returns {StreamPromise<UpdateTransferFnOutput>}
+     *
+     */
+    updateTransfer(input: UpdateTransferFnInput, options?: UpdateTransferFnOptions): StreamPromise<UpdateTransferFnOutput>;
+    /**
+     *
+     * Update the status and transfer_status of a TransferGroup
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.updateTransferGroup({
+     *   transfer_group: 'myCustom',
+     *   status: 'closed',
+     *   transfer_status: 'finished',
+     * }, {
+     *   return_transfers: true,
+     *   return_when_not_updated: true,
+     *   tracking_id: 'mylogId',
+     *   // transaction_id: Transaction.identifier, // created transaction identifier
+     * });
+     * expect(result).toEqual({
+     *   transfer_group: jasmine.objectContaining({
+     *     identifier: 'myCustom',
+     *     status: 'closed',
+     *     transfer_status: 'finished',
+     *   }),
+     *   transfers: [
+     *     jasmine.objectContaining({
+     *       identifier: 'transferA',
+     *       type: 'deposit',
+     *       status: 'finished',
+     *       from_wallet_foreign: 'EUR',
+     *       to_wallet_foreign: 'myWallet1',
+     *       token_foreign: 'EUR',
+     *     }),
+     *     jasmine.objectContaining({
+     *       identifier: 'transferB',
+     *       type: 'transfer',
+     *       status: 'finished',
+     *       from_wallet_foreign: 'myWallet1',
+     *       to_wallet_foreign: 'myWallet2',
+     *       token_foreign: 'EUR',
+     *     }),
+     *   ],
+     *   updated: true,
+     * });
+     *
+     * ```
+     *
+     * @param {UpdateTransferGroupFnInput} input
+     * @param {UpdateTransferGroupFnOptions} [options]
+     * @returns {StreamPromise<UpdateTransferGroupFnOutput>}
+     *
+     */
+    updateTransferGroup(input: UpdateTransferGroupFnInput, options?: UpdateTransferGroupFnOptions): StreamPromise<UpdateTransferGroupFnOutput>;
+    /**
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.updateTransferGroups()
+     *   .where({
+     *     status: 'open',
+     *   })
+     *   .whereIn('identifier', ['transferGroup1', 'transferGroup2'])
+     *   .whereMetadata('old', 'data')
+     *   .update({
+     *     transfer_status: 'finished',
+     *   })
+     *   .options({
+     *     return_transfers: true,
+     *   });
+     *
+     * ```
+     *
+     * @param {UpdateTransferGroupsFnInput} [input]
+     * @param {UpdateTransferGroupsFnOptions} [options]
+     * @returns {StreamPromise<UpdateTransferGroupsFnOutput>}
+     *
+     */
+    updateTransferGroups(): UpdateQueryBuilder<UpdateTransferGroupsFnFields, UpdateTransferGroupsFnStringFields, UpdateTransferGroupsFnMetadataFields, UpdateTransferGroupsFnResultFields, UpdateTransferGroupsFnUpdateFields, UpdateTransferGroupsFnOutput>;
+    updateTransferGroups(input: UpdateTransferGroupsFnInput, options?: UpdateTransferGroupsFnOptions): StreamPromise<UpdateTransferGroupsFnOutput>;
+    /**
+     *
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.updateTransfers({
+     *   metadata: {
+     *     example: 'test',
+     *   },
+     *   wallet: WALLETS.validId1.foreign,
+     *   token: 'EUR',
+     *   update: {
+     *     status: 'finished',
+     *   },
+     * });
+     *
+     * expect(result.transfers.length).toEqual(1);
+     * expect(result.transfers[0].status).toEqual('finished');
+     * expect(result.updated).toEqual(true);
+     *
+     * ```
+     *
+     * @param {UpdateTransfersFnInput} [input]
+     * @param {UpdateTransfersFnOptions} [options]
+     * @returns {StreamPromise<UpdateTransfersFnOutput>}
+     *
+     */
+    updateTransfers(): UpdateQueryBuilder<UpdateTransfersFnFields, UpdateTransfersFnStringFields, UpdateTransfersFnMetadataFields, UpdateTransfersFnResultFields, UpdateTransfersFnUpdateFields, UpdateTransfersFnOutput>;
+    updateTransfers(input: UpdateTransfersFnInput, options?: UpdateTransfersFnOptions): StreamPromise<UpdateTransfersFnOutput>;
+    /**
+     * Update Wallet
+     *
+     * ```javascript
+     *
+     * const result = await wapiClient.updateWallet(
+     *   {
+     *     wallet: WALLETS.withEURFunds0.foreign,
+     *     name: 'WT4',
+     *     status: 'disabled',
+     *     metadata: {
+     *       metadata_number: 2,
+     *     },
+     *   },
+     *   {
+     *     return_when_not_updated: true,
+     *     tracking_id: 'mylogId',
+     *     // transaction_id: Transaction.identifier, // created transaction identifier
+     *   },
+     * );
+     * expect(result).toEqual({
+     *   wallet: jasmine.objectContaining({
+     *     id: WALLETS.withEURFunds0.id,
+     *     foreign: WALLETS.withEURFunds0.foreign,
+     *     name: 'WT4',
+     *     metadata: {metadata_number: 2},
+     *     type: WALLETS.withEURFunds0.type,
+     *     status: 'disabled',
+     *     default_allow_negative: false,
+     *     default_allow_positive: true,
+     *     default_dtw_from: '011',
+     *     default_dtw_to: '110',
+     *   }),
+     *   updated: true,
+     * });
+     *
+     * ```
+     *
+     * @param {UpdateWalletFnInput} input
+     * @param {UpdateWalletFnOptions} [options]
+     * @returns {StreamPromise<UpdateWalletFnOutput>}
+     *
+     */
+    updateWallet(input: UpdateWalletFnInput, options?: UpdateWalletFnOptions): StreamPromise<UpdateWalletFnOutput>;
+}
+export declare function createClientWithWS(opts: WapiConnectionOptions, config?: ClientConfig): Client;
+export declare function createClientWithHttp(opts: WapiHttpConnectionOptions, config?: ClientConfig): Client;