/* tslint:disable */
/* eslint-disable */
/**
 * 
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import * as runtime from '../runtime';
import type {
  DepositHistory,
  EnrichedTx,
  NextNonce,
  RespSendTx,
  RespSendTxBatch,
  ResultCode,
  TransferHistory,
  Txs,
  WithdrawHistory,
} from '../models/index';
import {
    DepositHistoryFromJSON,
    DepositHistoryToJSON,
    EnrichedTxFromJSON,
    EnrichedTxToJSON,
    NextNonceFromJSON,
    NextNonceToJSON,
    RespSendTxFromJSON,
    RespSendTxToJSON,
    RespSendTxBatchFromJSON,
    RespSendTxBatchToJSON,
    ResultCodeFromJSON,
    ResultCodeToJSON,
    TransferHistoryFromJSON,
    TransferHistoryToJSON,
    TxsFromJSON,
    TxsToJSON,
    WithdrawHistoryFromJSON,
    WithdrawHistoryToJSON,
} from '../models/index';

export interface AccountTxsRequest {
    limit: number;
    by: AccountTxsByEnum;
    value: string;
    index?: number;
    authorization?: string;
    auth?: string;
    types?: Array<number>;
}

export interface BlockTxsRequest {
    by: BlockTxsByEnum;
    value: string;
}

export interface DepositHistoryRequest {
    account_index: number;
    l1_address: string;
    authorization?: string;
    auth?: string;
    cursor?: string;
    filter?: DepositHistoryFilterEnum;
}

export interface NextNonceRequest {
    account_index: number;
    api_key_index: number;
}

export interface SendTxRequest {
    tx_type: number;
    tx_info: string;
    price_protection?: boolean;
}

export interface SendTxBatchRequest {
    tx_types: string;
    tx_infos: string;
}

export interface SetAccountMetadataRequest {
    master_account_index: number;
    target_account_index: number;
    api_key_index: number;
    metadata: string;
    authorization?: string;
    auth?: string;
}

export interface TransferHistoryRequest {
    account_index: number;
    authorization?: string;
    auth?: string;
    cursor?: string;
    type?: Array<TransferHistoryTypeEnum>;
}

export interface TxRequest {
    by: TxByEnum;
    value: string;
}

export interface TxFromL1TxHashRequest {
    hash: string;
}

export interface TxsRequest {
    limit: number;
    index?: number;
}

export interface WithdrawHistoryRequest {
    account_index: number;
    authorization?: string;
    auth?: string;
    cursor?: string;
    filter?: WithdrawHistoryFilterEnum;
}

/**
 * 
 */
export class TransactionApi extends runtime.BaseAPI {

    /**
     * Get transactions of a specific account
     * accountTxs
     */
    async accountTxsRaw(requestParameters: AccountTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
        if (requestParameters['limit'] == null) {
            throw new runtime.RequiredError(
                'limit',
                'Required parameter "limit" was null or undefined when calling accountTxs().'
            );
        }

        if (requestParameters['by'] == null) {
            throw new runtime.RequiredError(
                'by',
                'Required parameter "by" was null or undefined when calling accountTxs().'
            );
        }

        if (requestParameters['value'] == null) {
            throw new runtime.RequiredError(
                'value',
                'Required parameter "value" was null or undefined when calling accountTxs().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['index'] != null) {
            queryParameters['index'] = requestParameters['index'];
        }

        if (requestParameters['limit'] != null) {
            queryParameters['limit'] = requestParameters['limit'];
        }

        if (requestParameters['by'] != null) {
            queryParameters['by'] = requestParameters['by'];
        }

        if (requestParameters['value'] != null) {
            queryParameters['value'] = requestParameters['value'];
        }

        if (requestParameters['authorization'] != null) {
            queryParameters['authorization'] = requestParameters['authorization'];
        }

        if (requestParameters['auth'] != null) {
            queryParameters['auth'] = requestParameters['auth'];
        }

        if (requestParameters['types'] != null) {
            queryParameters['types'] = requestParameters['types']!.join(runtime.COLLECTION_FORMATS["csv"]);
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/accountTxs`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TxsFromJSON(jsonValue));
    }

    /**
     * Get transactions of a specific account
     * accountTxs
     */
    async accountTxs(requestParameters: AccountTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
        const response = await this.accountTxsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get transactions in a block
     * blockTxs
     */
    async blockTxsRaw(requestParameters: BlockTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
        if (requestParameters['by'] == null) {
            throw new runtime.RequiredError(
                'by',
                'Required parameter "by" was null or undefined when calling blockTxs().'
            );
        }

        if (requestParameters['value'] == null) {
            throw new runtime.RequiredError(
                'value',
                'Required parameter "value" was null or undefined when calling blockTxs().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['by'] != null) {
            queryParameters['by'] = requestParameters['by'];
        }

        if (requestParameters['value'] != null) {
            queryParameters['value'] = requestParameters['value'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/blockTxs`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TxsFromJSON(jsonValue));
    }

    /**
     * Get transactions in a block
     * blockTxs
     */
    async blockTxs(requestParameters: BlockTxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
        const response = await this.blockTxsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get deposit history
     * deposit_history
     */
    async depositHistoryRaw(requestParameters: DepositHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DepositHistory>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling depositHistory().'
            );
        }

        if (requestParameters['l1_address'] == null) {
            throw new runtime.RequiredError(
                'l1_address',
                'Required parameter "l1_address" was null or undefined when calling depositHistory().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['authorization'] != null) {
            queryParameters['authorization'] = requestParameters['authorization'];
        }

        if (requestParameters['auth'] != null) {
            queryParameters['auth'] = requestParameters['auth'];
        }

        if (requestParameters['account_index'] != null) {
            queryParameters['account_index'] = requestParameters['account_index'];
        }

        if (requestParameters['l1_address'] != null) {
            queryParameters['l1_address'] = requestParameters['l1_address'];
        }

        if (requestParameters['cursor'] != null) {
            queryParameters['cursor'] = requestParameters['cursor'];
        }

        if (requestParameters['filter'] != null) {
            queryParameters['filter'] = requestParameters['filter'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/deposit/history`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => DepositHistoryFromJSON(jsonValue));
    }

    /**
     * Get deposit history
     * deposit_history
     */
    async depositHistory(requestParameters: DepositHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DepositHistory> {
        const response = await this.depositHistoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get next nonce for a specific account and api key
     * nextNonce
     */
    async nextNonceRaw(requestParameters: NextNonceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<NextNonce>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling nextNonce().'
            );
        }

        if (requestParameters['api_key_index'] == null) {
            throw new runtime.RequiredError(
                'api_key_index',
                'Required parameter "api_key_index" was null or undefined when calling nextNonce().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['account_index'] != null) {
            queryParameters['account_index'] = requestParameters['account_index'];
        }

        if (requestParameters['api_key_index'] != null) {
            queryParameters['api_key_index'] = requestParameters['api_key_index'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/nextNonce`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => NextNonceFromJSON(jsonValue));
    }

    /**
     * Get next nonce for a specific account and api key
     * nextNonce
     */
    async nextNonce(requestParameters: NextNonceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NextNonce> {
        const response = await this.nextNonceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * You need to sign the transaction body before sending it to the server. More details can be found in the Get Started docs: [Get Started For Programmers](https://apidocs.lighter.xyz/docs/get-started-for-programmers)
     * sendTx
     */
    async sendTxRaw(requestParameters: SendTxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespSendTx>> {
        if (requestParameters['tx_type'] == null) {
            throw new runtime.RequiredError(
                'tx_type',
                'Required parameter "tx_type" was null or undefined when calling sendTx().'
            );
        }

        if (requestParameters['tx_info'] == null) {
            throw new runtime.RequiredError(
                'tx_info',
                'Required parameter "tx_info" was null or undefined when calling sendTx().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters['tx_type'] != null) {
            formParams.append('tx_type', requestParameters['tx_type'] as any);
        }

        if (requestParameters['tx_info'] != null) {
            formParams.append('tx_info', requestParameters['tx_info'] as any);
        }

        if (requestParameters['price_protection'] != null) {
            formParams.append('price_protection', requestParameters['price_protection'] as any);
        }

        const response = await this.request({
            path: `/api/v1/sendTx`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RespSendTxFromJSON(jsonValue));
    }

    /**
     * You need to sign the transaction body before sending it to the server. More details can be found in the Get Started docs: [Get Started For Programmers](https://apidocs.lighter.xyz/docs/get-started-for-programmers)
     * sendTx
     */
    async sendTx(requestParameters: SendTxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespSendTx> {
        const response = await this.sendTxRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * You need to sign the transaction body before sending it to the server. More details can be found in the Get Started docs: [Get Started For Programmers](https://apidocs.lighter.xyz/docs/get-started-for-programmers)
     * sendTxBatch
     */
    async sendTxBatchRaw(requestParameters: SendTxBatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespSendTxBatch>> {
        if (requestParameters['tx_types'] == null) {
            throw new runtime.RequiredError(
                'tx_types',
                'Required parameter "tx_types" was null or undefined when calling sendTxBatch().'
            );
        }

        if (requestParameters['tx_infos'] == null) {
            throw new runtime.RequiredError(
                'tx_infos',
                'Required parameter "tx_infos" was null or undefined when calling sendTxBatch().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters['tx_types'] != null) {
            formParams.append('tx_types', requestParameters['tx_types'] as any);
        }

        if (requestParameters['tx_infos'] != null) {
            formParams.append('tx_infos', requestParameters['tx_infos'] as any);
        }

        const response = await this.request({
            path: `/api/v1/sendTxBatch`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RespSendTxBatchFromJSON(jsonValue));
    }

    /**
     * You need to sign the transaction body before sending it to the server. More details can be found in the Get Started docs: [Get Started For Programmers](https://apidocs.lighter.xyz/docs/get-started-for-programmers)
     * sendTxBatch
     */
    async sendTxBatch(requestParameters: SendTxBatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespSendTxBatch> {
        const response = await this.sendTxBatchRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Set account metadata
     * setAccountMetadata
     */
    async setAccountMetadataRaw(requestParameters: SetAccountMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ResultCode>> {
        if (requestParameters['master_account_index'] == null) {
            throw new runtime.RequiredError(
                'master_account_index',
                'Required parameter "master_account_index" was null or undefined when calling setAccountMetadata().'
            );
        }

        if (requestParameters['target_account_index'] == null) {
            throw new runtime.RequiredError(
                'target_account_index',
                'Required parameter "target_account_index" was null or undefined when calling setAccountMetadata().'
            );
        }

        if (requestParameters['api_key_index'] == null) {
            throw new runtime.RequiredError(
                'api_key_index',
                'Required parameter "api_key_index" was null or undefined when calling setAccountMetadata().'
            );
        }

        if (requestParameters['metadata'] == null) {
            throw new runtime.RequiredError(
                'metadata',
                'Required parameter "metadata" was null or undefined when calling setAccountMetadata().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (requestParameters['authorization'] != null) {
            headerParameters['authorization'] = String(requestParameters['authorization']);
        }

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters['master_account_index'] != null) {
            formParams.append('master_account_index', requestParameters['master_account_index'] as any);
        }

        if (requestParameters['target_account_index'] != null) {
            formParams.append('target_account_index', requestParameters['target_account_index'] as any);
        }

        if (requestParameters['api_key_index'] != null) {
            formParams.append('api_key_index', requestParameters['api_key_index'] as any);
        }

        if (requestParameters['metadata'] != null) {
            formParams.append('metadata', requestParameters['metadata'] as any);
        }

        if (requestParameters['auth'] != null) {
            formParams.append('auth', requestParameters['auth'] as any);
        }

        const response = await this.request({
            path: `/api/v1/setAccountMetadata`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ResultCodeFromJSON(jsonValue));
    }

    /**
     * Set account metadata
     * setAccountMetadata
     */
    async setAccountMetadata(requestParameters: SetAccountMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ResultCode> {
        const response = await this.setAccountMetadataRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get transfer history
     * transfer_history
     */
    async transferHistoryRaw(requestParameters: TransferHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TransferHistory>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling transferHistory().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['authorization'] != null) {
            queryParameters['authorization'] = requestParameters['authorization'];
        }

        if (requestParameters['auth'] != null) {
            queryParameters['auth'] = requestParameters['auth'];
        }

        if (requestParameters['account_index'] != null) {
            queryParameters['account_index'] = requestParameters['account_index'];
        }

        if (requestParameters['cursor'] != null) {
            queryParameters['cursor'] = requestParameters['cursor'];
        }

        if (requestParameters['type'] != null) {
            queryParameters['type'] = requestParameters['type']!.join(runtime.COLLECTION_FORMATS["csv"]);
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/transfer/history`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TransferHistoryFromJSON(jsonValue));
    }

    /**
     * Get transfer history
     * transfer_history
     */
    async transferHistory(requestParameters: TransferHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TransferHistory> {
        const response = await this.transferHistoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get transaction by hash or sequence index
     * tx
     */
    async txRaw(requestParameters: TxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrichedTx>> {
        if (requestParameters['by'] == null) {
            throw new runtime.RequiredError(
                'by',
                'Required parameter "by" was null or undefined when calling tx().'
            );
        }

        if (requestParameters['value'] == null) {
            throw new runtime.RequiredError(
                'value',
                'Required parameter "value" was null or undefined when calling tx().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['by'] != null) {
            queryParameters['by'] = requestParameters['by'];
        }

        if (requestParameters['value'] != null) {
            queryParameters['value'] = requestParameters['value'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/tx`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EnrichedTxFromJSON(jsonValue));
    }

    /**
     * Get transaction by hash or sequence index
     * tx
     */
    async tx(requestParameters: TxRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrichedTx> {
        const response = await this.txRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get L1 transaction by L1 transaction hash
     * txFromL1TxHash
     */
    async txFromL1TxHashRaw(requestParameters: TxFromL1TxHashRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrichedTx>> {
        if (requestParameters['hash'] == null) {
            throw new runtime.RequiredError(
                'hash',
                'Required parameter "hash" was null or undefined when calling txFromL1TxHash().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['hash'] != null) {
            queryParameters['hash'] = requestParameters['hash'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/txFromL1TxHash`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EnrichedTxFromJSON(jsonValue));
    }

    /**
     * Get L1 transaction by L1 transaction hash
     * txFromL1TxHash
     */
    async txFromL1TxHash(requestParameters: TxFromL1TxHashRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrichedTx> {
        const response = await this.txFromL1TxHashRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get transactions which are already packed into blocks
     * txs
     */
    async txsRaw(requestParameters: TxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Txs>> {
        if (requestParameters['limit'] == null) {
            throw new runtime.RequiredError(
                'limit',
                'Required parameter "limit" was null or undefined when calling txs().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['index'] != null) {
            queryParameters['index'] = requestParameters['index'];
        }

        if (requestParameters['limit'] != null) {
            queryParameters['limit'] = requestParameters['limit'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/txs`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TxsFromJSON(jsonValue));
    }

    /**
     * Get transactions which are already packed into blocks
     * txs
     */
    async txs(requestParameters: TxsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Txs> {
        const response = await this.txsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get withdraw history
     * withdraw_history
     */
    async withdrawHistoryRaw(requestParameters: WithdrawHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WithdrawHistory>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling withdrawHistory().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['authorization'] != null) {
            queryParameters['authorization'] = requestParameters['authorization'];
        }

        if (requestParameters['auth'] != null) {
            queryParameters['auth'] = requestParameters['auth'];
        }

        if (requestParameters['account_index'] != null) {
            queryParameters['account_index'] = requestParameters['account_index'];
        }

        if (requestParameters['cursor'] != null) {
            queryParameters['cursor'] = requestParameters['cursor'];
        }

        if (requestParameters['filter'] != null) {
            queryParameters['filter'] = requestParameters['filter'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/v1/withdraw/history`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => WithdrawHistoryFromJSON(jsonValue));
    }

    /**
     * Get withdraw history
     * withdraw_history
     */
    async withdrawHistory(requestParameters: WithdrawHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WithdrawHistory> {
        const response = await this.withdrawHistoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

}

/**
 * @export
 */
export const AccountTxsByEnum = {
    AccountIndex: 'account_index'
} as const;
export type AccountTxsByEnum = typeof AccountTxsByEnum[keyof typeof AccountTxsByEnum];
/**
 * @export
 */
export const BlockTxsByEnum = {
    Height: 'block_height',
    Commitment: 'block_commitment'
} as const;
export type BlockTxsByEnum = typeof BlockTxsByEnum[keyof typeof BlockTxsByEnum];
/**
 * @export
 */
export const DepositHistoryFilterEnum = {
    All: 'all',
    Pending: 'pending',
    Claimable: 'claimable'
} as const;
export type DepositHistoryFilterEnum = typeof DepositHistoryFilterEnum[keyof typeof DepositHistoryFilterEnum];
/**
 * @export
 */
export const TransferHistoryTypeEnum = {
    All: 'all',
    L2Transfer: 'L2Transfer',
    L2MintShares: 'L2MintShares',
    L2BurnShares: 'L2BurnShares',
    L2StakeAssets: 'L2StakeAssets',
    L2UnstakeAssets: 'L2UnstakeAssets'
} as const;
export type TransferHistoryTypeEnum = typeof TransferHistoryTypeEnum[keyof typeof TransferHistoryTypeEnum];
/**
 * @export
 */
export const TxByEnum = {
    Hash: 'hash',
    SequenceIndex: 'sequence_index'
} as const;
export type TxByEnum = typeof TxByEnum[keyof typeof TxByEnum];
/**
 * @export
 */
export const WithdrawHistoryFilterEnum = {
    All: 'all',
    Pending: 'pending',
    Claimable: 'claimable'
} as const;
export type WithdrawHistoryFilterEnum = typeof WithdrawHistoryFilterEnum[keyof typeof WithdrawHistoryFilterEnum];