/* 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 {
  AccountApiKeys,
  AccountLimits,
  AccountMetadatas,
  AccountPnL,
  AirdropAllocations,
  DetailedAccounts,
  IsWhitelisted,
  L1Metadata,
  Leaderboard,
  LiquidationInfos,
  PartnerStats,
  PositionFundings,
  RespChangeAccountTier,
  RespCreateRFQ,
  RespGetApiTokens,
  RespGetLeaseOptions,
  RespGetLeases,
  RespGetMakerOnlyApiKeys,
  RespGetRFQ,
  RespListRFQs,
  RespPostApiToken,
  RespPublicPoolsMetadata,
  RespRespondToRFQ,
  RespRevokeApiToken,
  RespSetMakerOnlyApiKeys,
  RespUpdateRFQ,
  ResultCode,
  SubAccounts,
  TxHash,
} from '../models/index';
import {
    AccountApiKeysFromJSON,
    AccountApiKeysToJSON,
    AccountLimitsFromJSON,
    AccountLimitsToJSON,
    AccountMetadatasFromJSON,
    AccountMetadatasToJSON,
    AccountPnLFromJSON,
    AccountPnLToJSON,
    AirdropAllocationsFromJSON,
    AirdropAllocationsToJSON,
    DetailedAccountsFromJSON,
    DetailedAccountsToJSON,
    IsWhitelistedFromJSON,
    IsWhitelistedToJSON,
    L1MetadataFromJSON,
    L1MetadataToJSON,
    LeaderboardFromJSON,
    LeaderboardToJSON,
    LiquidationInfosFromJSON,
    LiquidationInfosToJSON,
    PartnerStatsFromJSON,
    PartnerStatsToJSON,
    PositionFundingsFromJSON,
    PositionFundingsToJSON,
    RespChangeAccountTierFromJSON,
    RespChangeAccountTierToJSON,
    RespCreateRFQFromJSON,
    RespCreateRFQToJSON,
    RespGetApiTokensFromJSON,
    RespGetApiTokensToJSON,
    RespGetLeaseOptionsFromJSON,
    RespGetLeaseOptionsToJSON,
    RespGetLeasesFromJSON,
    RespGetLeasesToJSON,
    RespGetMakerOnlyApiKeysFromJSON,
    RespGetMakerOnlyApiKeysToJSON,
    RespGetRFQFromJSON,
    RespGetRFQToJSON,
    RespListRFQsFromJSON,
    RespListRFQsToJSON,
    RespPostApiTokenFromJSON,
    RespPostApiTokenToJSON,
    RespPublicPoolsMetadataFromJSON,
    RespPublicPoolsMetadataToJSON,
    RespRespondToRFQFromJSON,
    RespRespondToRFQToJSON,
    RespRevokeApiTokenFromJSON,
    RespRevokeApiTokenToJSON,
    RespSetMakerOnlyApiKeysFromJSON,
    RespSetMakerOnlyApiKeysToJSON,
    RespUpdateRFQFromJSON,
    RespUpdateRFQToJSON,
    ResultCodeFromJSON,
    ResultCodeToJSON,
    SubAccountsFromJSON,
    SubAccountsToJSON,
    TxHashFromJSON,
    TxHashToJSON,
} from '../models/index';

export interface AccountRequest {
    by: AccountByEnum;
    value: string;
    active_only?: boolean;
    cursor?: string;
}

export interface AccountLimitsRequest {
    account_index: number;
    authorization?: string;
    auth?: string;
}

export interface AccountMetadataRequest {
    by: AccountMetadataByEnum;
    value: string;
    authorization?: string;
    auth?: string;
    cursor?: string;
}

export interface AccountsByL1AddressRequest {
    l1_address: string;
    cursor?: string;
}

export interface AirdropRequest {
    l1_address: string;
    authorization?: string;
    auth?: string;
}

export interface AirdropCreateRequest {
    l1_address: string;
    allocations: string;
    signature: string;
    authorization?: string;
    auth?: string;
}

export interface ApikeysRequest {
    account_index: number;
    api_key_index?: number;
}

export interface ChangeAccountTierRequest {
    account_index: number;
    new_tier: string;
    authorization?: string;
    auth?: string;
}

export interface FaucetRequest {
    l1_address: string;
    do_l1_transfer: boolean;
}

export interface GetMakerOnlyApiKeysRequest {
    account_index: number;
    authorization?: string;
    auth?: string;
}

export interface IsWhitelistedRequest {
    l1_address: string;
}

export interface L1MetadataRequest {
    l1_address: string;
    authorization?: string;
    auth?: string;
}

export interface LeaderboardRequest {
    type: LeaderboardTypeEnum;
    authorization?: string;
    l1_address?: string;
    competition_id?: string;
    auth?: string;
}

export interface LeasesRequest {
    account_index: number;
    authorization?: string;
    auth?: string;
    cursor?: string;
    limit?: number;
}

export interface LiquidationsRequest {
    account_index: number;
    limit: number;
    authorization?: string;
    auth?: string;
    market_id?: number;
    cursor?: string;
}

export interface LitLeaseRequest {
    tx_info: string;
    lease_amount: string;
    duration_days: number;
    authorization?: string;
}

export interface PartnerStatsRequest {
    account_index: number;
    start_timestamp?: number;
    end_timestamp?: number;
}

export interface PnlRequest {
    by: PnlByEnum;
    value: string;
    resolution: PnlResolutionEnum;
    start_timestamp: number;
    end_timestamp: number;
    count_back: number;
    authorization?: string;
    auth?: string;
    ignore_transfers?: boolean;
}

export interface PositionFundingRequest {
    account_index: number;
    limit: number;
    authorization?: string;
    auth?: string;
    market_id?: number;
    cursor?: string;
    side?: PositionFundingSideEnum;
}

export interface PublicPoolsMetadataRequest {
    index: number;
    limit: number;
    authorization?: string;
    auth?: string;
    filter?: PublicPoolsMetadataFilterEnum;
    account_index?: number;
}

export interface RfqCreateRequest {
    market_index: number;
    direction: number;
    authorization?: string;
    auth?: string;
    base_amount?: string;
    quote_amount?: string;
    metadata?: string;
}

export interface RfqGetRequest {
    rfq_id: number;
    authorization?: string;
    auth?: string;
}

export interface RfqListRequest {
    authorization?: string;
    auth?: string;
    account_index?: number;
    status?: RfqListStatusEnum;
    cursor?: string;
    limit?: number;
}

export interface RfqRespondRequest {
    rfq_id: number;
    status: RfqRespondStatusEnum;
    authorization?: string;
    auth?: string;
}

export interface RfqUpdateRequest {
    rfq_id: number;
    status: RfqUpdateStatusEnum;
    authorization?: string;
    auth?: string;
}

export interface SetMakerOnlyApiKeysRequest {
    account_index: number;
    api_key_indexes: string;
    authorization?: string;
    auth?: string;
}

export interface TokensRequest {
    account_index: number;
    authorization?: string;
}

export interface TokensCreateRequest {
    name: string;
    account_index: number;
    expiry: number;
    sub_account_access: boolean;
    authorization?: string;
    scopes?: string;
}

export interface TokensRevokeRequest {
    token_id: number;
    account_index: number;
    authorization?: string;
}

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

    /**
     * Get account by account\'s index. <br>More details about account index: [Account Index](https://apidocs.lighter.xyz/docs/account-index)<hr>**Response Description:**<br><br>1) **Status:** 1 is active 0 is inactive.<br>2) **Collateral:** The amount of collateral in the account.<hr>**Position Details Description:**<br>1) **OOC:** Open order count in that market.<br>2) **Sign:** 1 for Long, -1 for Short.<br>3) **Position:** The amount of position in that market.<br>4) **Avg Entry Price:** The average entry price of the position.<br>5) **Position Value:** The value of the position.<br>6) **Unrealized PnL:** The unrealized profit and loss of the position.<br>7) **Realized PnL:** The realized profit and loss of the position.
     * account
     */
    async accountRaw(requestParameters: AccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DetailedAccounts>> {
        if (requestParameters['by'] == null) {
            throw new runtime.RequiredError(
                'by',
                'Required parameter "by" was null or undefined when calling account().'
            );
        }

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

        const queryParameters: any = {};

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get account by account\'s index. <br>More details about account index: [Account Index](https://apidocs.lighter.xyz/docs/account-index)<hr>**Response Description:**<br><br>1) **Status:** 1 is active 0 is inactive.<br>2) **Collateral:** The amount of collateral in the account.<hr>**Position Details Description:**<br>1) **OOC:** Open order count in that market.<br>2) **Sign:** 1 for Long, -1 for Short.<br>3) **Position:** The amount of position in that market.<br>4) **Avg Entry Price:** The average entry price of the position.<br>5) **Position Value:** The value of the position.<br>6) **Unrealized PnL:** The unrealized profit and loss of the position.<br>7) **Realized PnL:** The realized profit and loss of the position.
     * account
     */
    async account(requestParameters: AccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DetailedAccounts> {
        const response = await this.accountRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get account limits
     * accountLimits
     */
    async accountLimitsRaw(requestParameters: AccountLimitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountLimits>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling accountLimits().'
            );
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get account limits
     * accountLimits
     */
    async accountLimits(requestParameters: AccountLimitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountLimits> {
        const response = await this.accountLimitsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get account metadatas
     * accountMetadata
     */
    async accountMetadataRaw(requestParameters: AccountMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountMetadatas>> {
        if (requestParameters['by'] == null) {
            throw new runtime.RequiredError(
                'by',
                'Required parameter "by" was null or undefined when calling accountMetadata().'
            );
        }

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

        const queryParameters: any = {};

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * Get account metadatas
     * accountMetadata
     */
    async accountMetadata(requestParameters: AccountMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountMetadatas> {
        const response = await this.accountMetadataRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get accounts by l1_address returns all accounts associated with the given L1 address
     * accountsByL1Address
     */
    async accountsByL1AddressRaw(requestParameters: AccountsByL1AddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubAccounts>> {
        if (requestParameters['l1_address'] == null) {
            throw new runtime.RequiredError(
                'l1_address',
                'Required parameter "l1_address" was null or undefined when calling accountsByL1Address().'
            );
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get accounts by l1_address returns all accounts associated with the given L1 address
     * accountsByL1Address
     */
    async accountsByL1Address(requestParameters: AccountsByL1AddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubAccounts> {
        const response = await this.accountsByL1AddressRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get airdrop allocation
     * airdrop
     */
    async airdropRaw(requestParameters: AirdropRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AirdropAllocations>> {
        if (requestParameters['l1_address'] == null) {
            throw new runtime.RequiredError(
                'l1_address',
                'Required parameter "l1_address" was null or undefined when calling airdrop().'
            );
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * Get airdrop allocation
     * airdrop
     */
    async airdrop(requestParameters: AirdropRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AirdropAllocations> {
        const response = await this.airdropRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Create airdrop allocation
     * airdrop_create
     */
    async airdropCreateRaw(requestParameters: AirdropCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ResultCode>> {
        if (requestParameters['l1_address'] == null) {
            throw new runtime.RequiredError(
                'l1_address',
                'Required parameter "l1_address" was null or undefined when calling airdropCreate().'
            );
        }

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

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

        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['l1_address'] != null) {
            formParams.append('l1_address', requestParameters['l1_address'] as any);
        }

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

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

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

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

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

    /**
     * Create airdrop allocation
     * airdrop_create
     */
    async airdropCreate(requestParameters: AirdropCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ResultCode> {
        const response = await this.airdropCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get account api key. Set `api_key_index` to 255 to retrieve all api keys associated with the account.
     * apikeys
     */
    async apikeysRaw(requestParameters: ApikeysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountApiKeys>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling apikeys().'
            );
        }

        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/apikeys`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Get account api key. Set `api_key_index` to 255 to retrieve all api keys associated with the account.
     * apikeys
     */
    async apikeys(requestParameters: ApikeysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountApiKeys> {
        const response = await this.apikeysRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Change account tier
     * changeAccountTier
     */
    async changeAccountTierRaw(requestParameters: ChangeAccountTierRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespChangeAccountTier>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling changeAccountTier().'
            );
        }

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

        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['auth'] != null) {
            formParams.append('auth', requestParameters['auth'] as any);
        }

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

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

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

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

    /**
     * Change account tier
     * changeAccountTier
     */
    async changeAccountTier(requestParameters: ChangeAccountTierRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespChangeAccountTier> {
        const response = await this.changeAccountTierRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Request funds from faucet
     * faucet
     */
    async faucetRaw(requestParameters: FaucetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ResultCode>> {
        if (requestParameters['l1_address'] == null) {
            throw new runtime.RequiredError(
                'l1_address',
                'Required parameter "l1_address" was null or undefined when calling faucet().'
            );
        }

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

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Request funds from faucet
     * faucet
     */
    async faucet(requestParameters: FaucetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ResultCode> {
        const response = await this.faucetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get maker-only API key indexes
     * getMakerOnlyApiKeys
     */
    async getMakerOnlyApiKeysRaw(requestParameters: GetMakerOnlyApiKeysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetMakerOnlyApiKeys>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling getMakerOnlyApiKeys().'
            );
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * Get maker-only API key indexes
     * getMakerOnlyApiKeys
     */
    async getMakerOnlyApiKeys(requestParameters: GetMakerOnlyApiKeysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetMakerOnlyApiKeys> {
        const response = await this.getMakerOnlyApiKeysRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get is account whitelisted
     * isWhitelisted
     */
    async isWhitelistedRaw(requestParameters: IsWhitelistedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<IsWhitelisted>> {
        if (requestParameters['l1_address'] == null) {
            throw new runtime.RequiredError(
                'l1_address',
                'Required parameter "l1_address" was null or undefined when calling isWhitelisted().'
            );
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get is account whitelisted
     * isWhitelisted
     */
    async isWhitelisted(requestParameters: IsWhitelistedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<IsWhitelisted> {
        const response = await this.isWhitelistedRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get L1 metadata
     * l1Metadata
     */
    async l1MetadataRaw(requestParameters: L1MetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<L1Metadata>> {
        if (requestParameters['l1_address'] == null) {
            throw new runtime.RequiredError(
                'l1_address',
                'Required parameter "l1_address" was null or undefined when calling l1Metadata().'
            );
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * Get L1 metadata
     * l1Metadata
     */
    async l1Metadata(requestParameters: L1MetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<L1Metadata> {
        const response = await this.l1MetadataRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get points leaderboard
     * leaderboard
     */
    async leaderboardRaw(requestParameters: LeaderboardRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Leaderboard>> {
        if (requestParameters['type'] == null) {
            throw new runtime.RequiredError(
                'type',
                'Required parameter "type" was null or undefined when calling leaderboard().'
            );
        }

        const queryParameters: any = {};

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * Get points leaderboard
     * leaderboard
     */
    async leaderboard(requestParameters: LeaderboardRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Leaderboard> {
        const response = await this.leaderboardRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get lease options
     * leaseOptions
     */
    async leaseOptionsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetLeaseOptions>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get lease options
     * leaseOptions
     */
    async leaseOptions(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetLeaseOptions> {
        const response = await this.leaseOptionsRaw(initOverrides);
        return await response.value();
    }

    /**
     * Get leases
     * leases
     */
    async leasesRaw(requestParameters: LeasesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetLeases>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling leases().'
            );
        }

        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['limit'] != null) {
            queryParameters['limit'] = requestParameters['limit'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get leases
     * leases
     */
    async leases(requestParameters: LeasesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetLeases> {
        const response = await this.leasesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get liquidation infos
     * liquidations
     */
    async liquidationsRaw(requestParameters: LiquidationsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LiquidationInfos>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling liquidations().'
            );
        }

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

        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['market_id'] != null) {
            queryParameters['market_id'] = requestParameters['market_id'];
        }

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get liquidation infos
     * liquidations
     */
    async liquidations(requestParameters: LiquidationsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LiquidationInfos> {
        const response = await this.liquidationsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Submit LIT lease transfer
     * litLease
     */
    async litLeaseRaw(requestParameters: LitLeaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TxHash>> {
        if (requestParameters['tx_info'] == null) {
            throw new runtime.RequiredError(
                'tx_info',
                'Required parameter "tx_info" was null or undefined when calling litLease().'
            );
        }

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

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

        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['tx_info'] != null) {
            formParams.append('tx_info', requestParameters['tx_info'] as any);
        }

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

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

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

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

    /**
     * Submit LIT lease transfer
     * litLease
     */
    async litLease(requestParameters: LitLeaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TxHash> {
        const response = await this.litLeaseRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get partner stats
     * partnerStats
     */
    async partnerStatsRaw(requestParameters: PartnerStatsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PartnerStats>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling partnerStats().'
            );
        }

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get partner stats
     * partnerStats
     */
    async partnerStats(requestParameters: PartnerStatsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PartnerStats> {
        const response = await this.partnerStatsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get account PnL chart
     * pnl
     */
    async pnlRaw(requestParameters: PnlRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountPnL>> {
        if (requestParameters['by'] == null) {
            throw new runtime.RequiredError(
                'by',
                'Required parameter "by" was null or undefined when calling pnl().'
            );
        }

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

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

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

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

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

        const queryParameters: any = {};

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

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

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

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get account PnL chart
     * pnl
     */
    async pnl(requestParameters: PnlRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountPnL> {
        const response = await this.pnlRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get accounts position fundings
     * positionFunding
     */
    async positionFundingRaw(requestParameters: PositionFundingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PositionFundings>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling positionFunding().'
            );
        }

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

        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['market_id'] != null) {
            queryParameters['market_id'] = requestParameters['market_id'];
        }

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get accounts position fundings
     * positionFunding
     */
    async positionFunding(requestParameters: PositionFundingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PositionFundings> {
        const response = await this.positionFundingRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get public pools metadata
     * publicPoolsMetadata
     */
    async publicPoolsMetadataRaw(requestParameters: PublicPoolsMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespPublicPoolsMetadata>> {
        if (requestParameters['index'] == null) {
            throw new runtime.RequiredError(
                'index',
                'Required parameter "index" was null or undefined when calling publicPoolsMetadata().'
            );
        }

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

        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

    /**
     * Get public pools metadata
     * publicPoolsMetadata
     */
    async publicPoolsMetadata(requestParameters: PublicPoolsMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespPublicPoolsMetadata> {
        const response = await this.publicPoolsMetadataRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Create RFQ
     * rfq_create
     */
    async rfqCreateRaw(requestParameters: RfqCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespCreateRFQ>> {
        if (requestParameters['market_index'] == null) {
            throw new runtime.RequiredError(
                'market_index',
                'Required parameter "market_index" was null or undefined when calling rfqCreate().'
            );
        }

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

        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['auth'] != null) {
            formParams.append('auth', requestParameters['auth'] as any);
        }

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

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

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

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

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

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

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

    /**
     * Create RFQ
     * rfq_create
     */
    async rfqCreate(requestParameters: RfqCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespCreateRFQ> {
        const response = await this.rfqCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get RFQ by ID
     * rfq_get
     */
    async rfqGetRaw(requestParameters: RfqGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetRFQ>> {
        if (requestParameters['rfq_id'] == null) {
            throw new runtime.RequiredError(
                'rfq_id',
                'Required parameter "rfq_id" was null or undefined when calling rfqGet().'
            );
        }

        const queryParameters: any = {};

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * Get RFQ by ID
     * rfq_get
     */
    async rfqGet(requestParameters: RfqGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetRFQ> {
        const response = await this.rfqGetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * List RFQs
     * rfq_list
     */
    async rfqListRaw(requestParameters: RfqListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespListRFQs>> {
        const queryParameters: any = {};

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * List RFQs
     * rfq_list
     */
    async rfqList(requestParameters: RfqListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespListRFQs> {
        const response = await this.rfqListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Respond to RFQ
     * rfq_respond
     */
    async rfqRespondRaw(requestParameters: RfqRespondRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespRespondToRFQ>> {
        if (requestParameters['rfq_id'] == null) {
            throw new runtime.RequiredError(
                'rfq_id',
                'Required parameter "rfq_id" was null or undefined when calling rfqRespond().'
            );
        }

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

        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['auth'] != null) {
            formParams.append('auth', requestParameters['auth'] as any);
        }

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

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

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

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

    /**
     * Respond to RFQ
     * rfq_respond
     */
    async rfqRespond(requestParameters: RfqRespondRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespRespondToRFQ> {
        const response = await this.rfqRespondRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Update RFQ status
     * rfq_update
     */
    async rfqUpdateRaw(requestParameters: RfqUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespUpdateRFQ>> {
        if (requestParameters['rfq_id'] == null) {
            throw new runtime.RequiredError(
                'rfq_id',
                'Required parameter "rfq_id" was null or undefined when calling rfqUpdate().'
            );
        }

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

        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['auth'] != null) {
            formParams.append('auth', requestParameters['auth'] as any);
        }

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

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

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

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

    /**
     * Update RFQ status
     * rfq_update
     */
    async rfqUpdate(requestParameters: RfqUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespUpdateRFQ> {
        const response = await this.rfqUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Set maker-only API key indexes
     * setMakerOnlyApiKeys
     */
    async setMakerOnlyApiKeysRaw(requestParameters: SetMakerOnlyApiKeysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespSetMakerOnlyApiKeys>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling setMakerOnlyApiKeys().'
            );
        }

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

        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['auth'] != null) {
            formParams.append('auth', requestParameters['auth'] as any);
        }

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

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

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

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

    /**
     * Set maker-only API key indexes
     * setMakerOnlyApiKeys
     */
    async setMakerOnlyApiKeys(requestParameters: SetMakerOnlyApiKeysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespSetMakerOnlyApiKeys> {
        const response = await this.setMakerOnlyApiKeysRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get api tokens of an account
     * tokens
     */
    async tokensRaw(requestParameters: TokensRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetApiTokens>> {
        if (requestParameters['account_index'] == null) {
            throw new runtime.RequiredError(
                'account_index',
                'Required parameter "account_index" was null or undefined when calling tokens().'
            );
        }

        const queryParameters: any = {};

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

        const headerParameters: runtime.HTTPHeaders = {};

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

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

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

    /**
     * Get api tokens of an account
     * tokens
     */
    async tokens(requestParameters: TokensRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetApiTokens> {
        const response = await this.tokensRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Create api token
     * tokens_create
     */
    async tokensCreateRaw(requestParameters: TokensCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespPostApiToken>> {
        if (requestParameters['name'] == null) {
            throw new runtime.RequiredError(
                'name',
                'Required parameter "name" was null or undefined when calling tokensCreate().'
            );
        }

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

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

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

        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['name'] != null) {
            formParams.append('name', requestParameters['name'] as any);
        }

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

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

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

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

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

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

    /**
     * Create api token
     * tokens_create
     */
    async tokensCreate(requestParameters: TokensCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespPostApiToken> {
        const response = await this.tokensCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Revoke api token
     * tokens_revoke
     */
    async tokensRevokeRaw(requestParameters: TokensRevokeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespRevokeApiToken>> {
        if (requestParameters['token_id'] == null) {
            throw new runtime.RequiredError(
                'token_id',
                'Required parameter "token_id" was null or undefined when calling tokensRevoke().'
            );
        }

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

        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['token_id'] != null) {
            formParams.append('token_id', requestParameters['token_id'] as any);
        }

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

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

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

    /**
     * Revoke api token
     * tokens_revoke
     */
    async tokensRevoke(requestParameters: TokensRevokeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespRevokeApiToken> {
        const response = await this.tokensRevokeRaw(requestParameters, initOverrides);
        return await response.value();
    }

}

/**
 * @export
 */
export const AccountByEnum = {
    Index: 'index',
    L1Address: 'l1_address'
} as const;
export type AccountByEnum = typeof AccountByEnum[keyof typeof AccountByEnum];
/**
 * @export
 */
export const AccountMetadataByEnum = {
    Index: 'index',
    L1Address: 'l1_address'
} as const;
export type AccountMetadataByEnum = typeof AccountMetadataByEnum[keyof typeof AccountMetadataByEnum];
/**
 * @export
 */
export const LeaderboardTypeEnum = {
    Weekly: 'weekly',
    All: 'all',
    Competition: 'competition'
} as const;
export type LeaderboardTypeEnum = typeof LeaderboardTypeEnum[keyof typeof LeaderboardTypeEnum];
/**
 * @export
 */
export const PnlByEnum = {
    Index: 'index'
} as const;
export type PnlByEnum = typeof PnlByEnum[keyof typeof PnlByEnum];
/**
 * @export
 */
export const PnlResolutionEnum = {
    _1m: '1m',
    _5m: '5m',
    _15m: '15m',
    _1h: '1h',
    _4h: '4h',
    _1d: '1d'
} as const;
export type PnlResolutionEnum = typeof PnlResolutionEnum[keyof typeof PnlResolutionEnum];
/**
 * @export
 */
export const PositionFundingSideEnum = {
    Long: 'long',
    Short: 'short',
    All: 'all'
} as const;
export type PositionFundingSideEnum = typeof PositionFundingSideEnum[keyof typeof PositionFundingSideEnum];
/**
 * @export
 */
export const PublicPoolsMetadataFilterEnum = {
    All: 'all',
    User: 'user',
    Protocol: 'protocol',
    AccountIndex: 'account_index',
    Stake: 'stake'
} as const;
export type PublicPoolsMetadataFilterEnum = typeof PublicPoolsMetadataFilterEnum[keyof typeof PublicPoolsMetadataFilterEnum];
/**
 * @export
 */
export const RfqListStatusEnum = {
    Opened: 'opened',
    OrderCreated: 'order_created',
    Closed: 'closed'
} as const;
export type RfqListStatusEnum = typeof RfqListStatusEnum[keyof typeof RfqListStatusEnum];
/**
 * @export
 */
export const RfqRespondStatusEnum = {
    Acknowledged: 'acknowledged',
    LiquidityProvided: 'liquidity_provided',
    NotInterested: 'not_interested'
} as const;
export type RfqRespondStatusEnum = typeof RfqRespondStatusEnum[keyof typeof RfqRespondStatusEnum];
/**
 * @export
 */
export const RfqUpdateStatusEnum = {
    OrderCreated: 'order_created',
    Closed: 'closed'
} as const;
export type RfqUpdateStatusEnum = typeof RfqUpdateStatusEnum[keyof typeof RfqUpdateStatusEnum];