ccxt-go/exchange_wrapper_structs.go

package ccxt
// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code


type Options struct {
    Params *map[string]interface{}
}

type FetchTickerOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTickerOptions func(opts *FetchTickerOptionsStruct)

func WithFetchTickerParams(params map[string]interface{}) FetchTickerOptions {
    return func(opts *FetchTickerOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTickersOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchTickersOptions func(opts *FetchTickersOptionsStruct)

func WithFetchTickersSymbols(symbols []string) FetchTickersOptions {
    return func(opts *FetchTickersOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchTickersParams(params map[string]interface{}) FetchTickersOptions {
    return func(opts *FetchTickersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrderBookOptionsStruct struct {
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrderBookOptions func(opts *FetchOrderBookOptionsStruct)

func WithFetchOrderBookLimit(limit int64) FetchOrderBookOptions {
    return func(opts *FetchOrderBookOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrderBookParams(params map[string]interface{}) FetchOrderBookOptions {
    return func(opts *FetchOrderBookOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOHLCVOptionsStruct struct {
    Timeframe *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOHLCVOptions func(opts *FetchOHLCVOptionsStruct)

func WithFetchOHLCVTimeframe(timeframe string) FetchOHLCVOptions {
    return func(opts *FetchOHLCVOptionsStruct) {
        opts.Timeframe = &timeframe
    }
}


func WithFetchOHLCVSince(since int64) FetchOHLCVOptions {
    return func(opts *FetchOHLCVOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOHLCVLimit(limit int64) FetchOHLCVOptions {
    return func(opts *FetchOHLCVOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOHLCVParams(params map[string]interface{}) FetchOHLCVOptions {
    return func(opts *FetchOHLCVOptionsStruct) {
        opts.Params = &params
    }
}


type CreateOrderOptionsStruct struct {
    Price *float64
    Params *map[string]interface{}
}

type CreateOrderOptions func(opts *CreateOrderOptionsStruct)

func WithCreateOrderPrice(price float64) CreateOrderOptions {
    return func(opts *CreateOrderOptionsStruct) {
        opts.Price = &price
    }
}


func WithCreateOrderParams(params map[string]interface{}) CreateOrderOptions {
    return func(opts *CreateOrderOptionsStruct) {
        opts.Params = &params
    }
}


type CancelOrderOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type CancelOrderOptions func(opts *CancelOrderOptionsStruct)

func WithCancelOrderSymbol(symbol string) CancelOrderOptions {
    return func(opts *CancelOrderOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithCancelOrderParams(params map[string]interface{}) CancelOrderOptions {
    return func(opts *CancelOrderOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrderOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchOrderOptions func(opts *FetchOrderOptionsStruct)

func WithFetchOrderSymbol(symbol string) FetchOrderOptions {
    return func(opts *FetchOrderOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrderParams(params map[string]interface{}) FetchOrderOptions {
    return func(opts *FetchOrderOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOpenOrdersOptions func(opts *FetchOpenOrdersOptionsStruct)

func WithFetchOpenOrdersSymbol(symbol string) FetchOpenOrdersOptions {
    return func(opts *FetchOpenOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOpenOrdersSince(since int64) FetchOpenOrdersOptions {
    return func(opts *FetchOpenOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOpenOrdersLimit(limit int64) FetchOpenOrdersOptions {
    return func(opts *FetchOpenOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOpenOrdersParams(params map[string]interface{}) FetchOpenOrdersOptions {
    return func(opts *FetchOpenOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrderTradesOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrderTradesOptions func(opts *FetchOrderTradesOptionsStruct)

func WithFetchOrderTradesSymbol(symbol string) FetchOrderTradesOptions {
    return func(opts *FetchOrderTradesOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrderTradesSince(since int64) FetchOrderTradesOptions {
    return func(opts *FetchOrderTradesOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrderTradesLimit(limit int64) FetchOrderTradesOptions {
    return func(opts *FetchOrderTradesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrderTradesParams(params map[string]interface{}) FetchOrderTradesOptions {
    return func(opts *FetchOrderTradesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMyTradesOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchMyTradesOptions func(opts *FetchMyTradesOptionsStruct)

func WithFetchMyTradesSymbol(symbol string) FetchMyTradesOptions {
    return func(opts *FetchMyTradesOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchMyTradesSince(since int64) FetchMyTradesOptions {
    return func(opts *FetchMyTradesOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchMyTradesLimit(limit int64) FetchMyTradesOptions {
    return func(opts *FetchMyTradesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchMyTradesParams(params map[string]interface{}) FetchMyTradesOptions {
    return func(opts *FetchMyTradesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTradesOptionsStruct struct {
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchTradesOptions func(opts *FetchTradesOptionsStruct)

func WithFetchTradesSince(since int64) FetchTradesOptions {
    return func(opts *FetchTradesOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchTradesLimit(limit int64) FetchTradesOptions {
    return func(opts *FetchTradesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchTradesParams(params map[string]interface{}) FetchTradesOptions {
    return func(opts *FetchTradesOptionsStruct) {
        opts.Params = &params
    }
}


type CreateMarketOrderWithCostOptionsStruct struct {
    Params *map[string]interface{}
}

type CreateMarketOrderWithCostOptions func(opts *CreateMarketOrderWithCostOptionsStruct)

func WithCreateMarketOrderWithCostParams(params map[string]interface{}) CreateMarketOrderWithCostOptions {
    return func(opts *CreateMarketOrderWithCostOptionsStruct) {
        opts.Params = &params
    }
}


type CreateMarketBuyOrderWithCostOptionsStruct struct {
    Params *map[string]interface{}
}

type CreateMarketBuyOrderWithCostOptions func(opts *CreateMarketBuyOrderWithCostOptionsStruct)

func WithCreateMarketBuyOrderWithCostParams(params map[string]interface{}) CreateMarketBuyOrderWithCostOptions {
    return func(opts *CreateMarketBuyOrderWithCostOptionsStruct) {
        opts.Params = &params
    }
}


type CreateMarketSellOrderWithCostOptionsStruct struct {
    Params *map[string]interface{}
}

type CreateMarketSellOrderWithCostOptions func(opts *CreateMarketSellOrderWithCostOptionsStruct)

func WithCreateMarketSellOrderWithCostParams(params map[string]interface{}) CreateMarketSellOrderWithCostOptions {
    return func(opts *CreateMarketSellOrderWithCostOptionsStruct) {
        opts.Params = &params
    }
}


type CancelAllOrdersOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type CancelAllOrdersOptions func(opts *CancelAllOrdersOptionsStruct)

func WithCancelAllOrdersSymbol(symbol string) CancelAllOrdersOptions {
    return func(opts *CancelAllOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithCancelAllOrdersParams(params map[string]interface{}) CancelAllOrdersOptions {
    return func(opts *CancelAllOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrdersOptions func(opts *FetchOrdersOptionsStruct)

func WithFetchOrdersSymbol(symbol string) FetchOrdersOptions {
    return func(opts *FetchOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersSince(since int64) FetchOrdersOptions {
    return func(opts *FetchOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrdersLimit(limit int64) FetchOrdersOptions {
    return func(opts *FetchOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrdersParams(params map[string]interface{}) FetchOrdersOptions {
    return func(opts *FetchOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchClosedOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchClosedOrdersOptions func(opts *FetchClosedOrdersOptionsStruct)

func WithFetchClosedOrdersSymbol(symbol string) FetchClosedOrdersOptions {
    return func(opts *FetchClosedOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchClosedOrdersSince(since int64) FetchClosedOrdersOptions {
    return func(opts *FetchClosedOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchClosedOrdersLimit(limit int64) FetchClosedOrdersOptions {
    return func(opts *FetchClosedOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchClosedOrdersParams(params map[string]interface{}) FetchClosedOrdersOptions {
    return func(opts *FetchClosedOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type EditOrderOptionsStruct struct {
    Amount *float64
    Price *float64
    Params *map[string]interface{}
}

type EditOrderOptions func(opts *EditOrderOptionsStruct)

func WithEditOrderAmount(amount float64) EditOrderOptions {
    return func(opts *EditOrderOptionsStruct) {
        opts.Amount = &amount
    }
}


func WithEditOrderPrice(price float64) EditOrderOptions {
    return func(opts *EditOrderOptionsStruct) {
        opts.Price = &price
    }
}


func WithEditOrderParams(params map[string]interface{}) EditOrderOptions {
    return func(opts *EditOrderOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositAddressOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchDepositAddressOptions func(opts *FetchDepositAddressOptionsStruct)

func WithFetchDepositAddressParams(params map[string]interface{}) FetchDepositAddressOptions {
    return func(opts *FetchDepositAddressOptionsStruct) {
        opts.Params = &params
    }
}


type WithdrawOptionsStruct struct {
    Tag *interface{}
    Params *map[string]interface{}
}

type WithdrawOptions func(opts *WithdrawOptionsStruct)

func WithWithdrawTag(tag interface{}) WithdrawOptions {
    return func(opts *WithdrawOptionsStruct) {
        opts.Tag = &tag
    }
}


func WithWithdrawParams(params map[string]interface{}) WithdrawOptions {
    return func(opts *WithdrawOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositsWithdrawalsOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchDepositsWithdrawalsOptions func(opts *FetchDepositsWithdrawalsOptionsStruct)

func WithFetchDepositsWithdrawalsCode(code string) FetchDepositsWithdrawalsOptions {
    return func(opts *FetchDepositsWithdrawalsOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchDepositsWithdrawalsSince(since int64) FetchDepositsWithdrawalsOptions {
    return func(opts *FetchDepositsWithdrawalsOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchDepositsWithdrawalsLimit(limit int64) FetchDepositsWithdrawalsOptions {
    return func(opts *FetchDepositsWithdrawalsOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchDepositsWithdrawalsParams(params map[string]interface{}) FetchDepositsWithdrawalsOptions {
    return func(opts *FetchDepositsWithdrawalsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositsOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchDepositsOptions func(opts *FetchDepositsOptionsStruct)

func WithFetchDepositsCode(code string) FetchDepositsOptions {
    return func(opts *FetchDepositsOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchDepositsSince(since int64) FetchDepositsOptions {
    return func(opts *FetchDepositsOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchDepositsLimit(limit int64) FetchDepositsOptions {
    return func(opts *FetchDepositsOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchDepositsParams(params map[string]interface{}) FetchDepositsOptions {
    return func(opts *FetchDepositsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchWithdrawalsOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchWithdrawalsOptions func(opts *FetchWithdrawalsOptionsStruct)

func WithFetchWithdrawalsCode(code string) FetchWithdrawalsOptions {
    return func(opts *FetchWithdrawalsOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchWithdrawalsSince(since int64) FetchWithdrawalsOptions {
    return func(opts *FetchWithdrawalsOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchWithdrawalsLimit(limit int64) FetchWithdrawalsOptions {
    return func(opts *FetchWithdrawalsOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchWithdrawalsParams(params map[string]interface{}) FetchWithdrawalsOptions {
    return func(opts *FetchWithdrawalsOptionsStruct) {
        opts.Params = &params
    }
}


type CreateOrdersOptionsStruct struct {
    Params *map[string]interface{}
}

type CreateOrdersOptions func(opts *CreateOrdersOptionsStruct)

func WithCreateOrdersParams(params map[string]interface{}) CreateOrdersOptions {
    return func(opts *CreateOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPositionsOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchPositionsOptions func(opts *FetchPositionsOptionsStruct)

func WithFetchPositionsSymbols(symbols []string) FetchPositionsOptions {
    return func(opts *FetchPositionsOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchPositionsParams(params map[string]interface{}) FetchPositionsOptions {
    return func(opts *FetchPositionsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchFundingRatesOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchFundingRatesOptions func(opts *FetchFundingRatesOptionsStruct)

func WithFetchFundingRatesSymbols(symbols []string) FetchFundingRatesOptions {
    return func(opts *FetchFundingRatesOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchFundingRatesParams(params map[string]interface{}) FetchFundingRatesOptions {
    return func(opts *FetchFundingRatesOptionsStruct) {
        opts.Params = &params
    }
}


type SetLeverageOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type SetLeverageOptions func(opts *SetLeverageOptionsStruct)

func WithSetLeverageSymbol(symbol string) SetLeverageOptions {
    return func(opts *SetLeverageOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithSetLeverageParams(params map[string]interface{}) SetLeverageOptions {
    return func(opts *SetLeverageOptionsStruct) {
        opts.Params = &params
    }
}


type SetMarginModeOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type SetMarginModeOptions func(opts *SetMarginModeOptionsStruct)

func WithSetMarginModeSymbol(symbol string) SetMarginModeOptions {
    return func(opts *SetMarginModeOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithSetMarginModeParams(params map[string]interface{}) SetMarginModeOptions {
    return func(opts *SetMarginModeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLeverageTiersOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchLeverageTiersOptions func(opts *FetchLeverageTiersOptionsStruct)

func WithFetchLeverageTiersSymbols(symbols []string) FetchLeverageTiersOptions {
    return func(opts *FetchLeverageTiersOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchLeverageTiersParams(params map[string]interface{}) FetchLeverageTiersOptions {
    return func(opts *FetchLeverageTiersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositWithdrawFeesOptionsStruct struct {
    Codes *[]string
    Params *map[string]interface{}
}

type FetchDepositWithdrawFeesOptions func(opts *FetchDepositWithdrawFeesOptionsStruct)

func WithFetchDepositWithdrawFeesCodes(codes []string) FetchDepositWithdrawFeesOptions {
    return func(opts *FetchDepositWithdrawFeesOptionsStruct) {
        opts.Codes = &codes
    }
}


func WithFetchDepositWithdrawFeesParams(params map[string]interface{}) FetchDepositWithdrawFeesOptions {
    return func(opts *FetchDepositWithdrawFeesOptionsStruct) {
        opts.Params = &params
    }
}


type TransferOptionsStruct struct {
    Params *map[string]interface{}
}

type TransferOptions func(opts *TransferOptionsStruct)

func WithTransferParams(params map[string]interface{}) TransferOptions {
    return func(opts *TransferOptionsStruct) {
        opts.Params = &params
    }
}


type FetchFundingHistoryOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchFundingHistoryOptions func(opts *FetchFundingHistoryOptionsStruct)

func WithFetchFundingHistorySymbol(symbol string) FetchFundingHistoryOptions {
    return func(opts *FetchFundingHistoryOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchFundingHistorySince(since int64) FetchFundingHistoryOptions {
    return func(opts *FetchFundingHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchFundingHistoryLimit(limit int64) FetchFundingHistoryOptions {
    return func(opts *FetchFundingHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchFundingHistoryParams(params map[string]interface{}) FetchFundingHistoryOptions {
    return func(opts *FetchFundingHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarginModesOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchMarginModesOptions func(opts *FetchMarginModesOptionsStruct)

func WithFetchMarginModesSymbols(symbols []string) FetchMarginModesOptions {
    return func(opts *FetchMarginModesOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchMarginModesParams(params map[string]interface{}) FetchMarginModesOptions {
    return func(opts *FetchMarginModesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLeveragesOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchLeveragesOptions func(opts *FetchLeveragesOptionsStruct)

func WithFetchLeveragesSymbols(symbols []string) FetchLeveragesOptions {
    return func(opts *FetchLeveragesOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchLeveragesParams(params map[string]interface{}) FetchLeveragesOptions {
    return func(opts *FetchLeveragesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchBidsAsksOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchBidsAsksOptions func(opts *FetchBidsAsksOptionsStruct)

func WithFetchBidsAsksSymbols(symbols []string) FetchBidsAsksOptions {
    return func(opts *FetchBidsAsksOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchBidsAsksParams(params map[string]interface{}) FetchBidsAsksOptions {
    return func(opts *FetchBidsAsksOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLastPricesOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchLastPricesOptions func(opts *FetchLastPricesOptionsStruct)

func WithFetchLastPricesSymbols(symbols []string) FetchLastPricesOptions {
    return func(opts *FetchLastPricesOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchLastPricesParams(params map[string]interface{}) FetchLastPricesOptions {
    return func(opts *FetchLastPricesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarkPriceOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchMarkPriceOptions func(opts *FetchMarkPriceOptionsStruct)

func WithFetchMarkPriceParams(params map[string]interface{}) FetchMarkPriceOptions {
    return func(opts *FetchMarkPriceOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarkPricesOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchMarkPricesOptions func(opts *FetchMarkPricesOptionsStruct)

func WithFetchMarkPricesSymbols(symbols []string) FetchMarkPricesOptions {
    return func(opts *FetchMarkPricesOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchMarkPricesParams(params map[string]interface{}) FetchMarkPricesOptions {
    return func(opts *FetchMarkPricesOptionsStruct) {
        opts.Params = &params
    }
}


type EditSpotOrderOptionsStruct struct {
    Price *float64
    Params *map[string]interface{}
}

type EditSpotOrderOptions func(opts *EditSpotOrderOptionsStruct)

func WithEditSpotOrderPrice(price float64) EditSpotOrderOptions {
    return func(opts *EditSpotOrderOptionsStruct) {
        opts.Price = &price
    }
}


func WithEditSpotOrderParams(params map[string]interface{}) EditSpotOrderOptions {
    return func(opts *EditSpotOrderOptionsStruct) {
        opts.Params = &params
    }
}


type EditContractOrderOptionsStruct struct {
    Price *float64
    Params *map[string]interface{}
}

type EditContractOrderOptions func(opts *EditContractOrderOptionsStruct)

func WithEditContractOrderPrice(price float64) EditContractOrderOptions {
    return func(opts *EditContractOrderOptionsStruct) {
        opts.Price = &price
    }
}


func WithEditContractOrderParams(params map[string]interface{}) EditContractOrderOptions {
    return func(opts *EditContractOrderOptionsStruct) {
        opts.Params = &params
    }
}


type EditOrdersOptionsStruct struct {
    Params *map[string]interface{}
}

type EditOrdersOptions func(opts *EditOrdersOptionsStruct)

func WithEditOrdersParams(params map[string]interface{}) EditOrdersOptions {
    return func(opts *EditOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenOrderOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchOpenOrderOptions func(opts *FetchOpenOrderOptionsStruct)

func WithFetchOpenOrderSymbol(symbol string) FetchOpenOrderOptions {
    return func(opts *FetchOpenOrderOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOpenOrderParams(params map[string]interface{}) FetchOpenOrderOptions {
    return func(opts *FetchOpenOrderOptionsStruct) {
        opts.Params = &params
    }
}


type FetchCanceledOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchCanceledOrdersOptions func(opts *FetchCanceledOrdersOptionsStruct)

func WithFetchCanceledOrdersSymbol(symbol string) FetchCanceledOrdersOptions {
    return func(opts *FetchCanceledOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchCanceledOrdersSince(since int64) FetchCanceledOrdersOptions {
    return func(opts *FetchCanceledOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchCanceledOrdersLimit(limit int64) FetchCanceledOrdersOptions {
    return func(opts *FetchCanceledOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchCanceledOrdersParams(params map[string]interface{}) FetchCanceledOrdersOptions {
    return func(opts *FetchCanceledOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchCanceledAndClosedOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchCanceledAndClosedOrdersOptions func(opts *FetchCanceledAndClosedOrdersOptionsStruct)

func WithFetchCanceledAndClosedOrdersSymbol(symbol string) FetchCanceledAndClosedOrdersOptions {
    return func(opts *FetchCanceledAndClosedOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchCanceledAndClosedOrdersSince(since int64) FetchCanceledAndClosedOrdersOptions {
    return func(opts *FetchCanceledAndClosedOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchCanceledAndClosedOrdersLimit(limit int64) FetchCanceledAndClosedOrdersOptions {
    return func(opts *FetchCanceledAndClosedOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchCanceledAndClosedOrdersParams(params map[string]interface{}) FetchCanceledAndClosedOrdersOptions {
    return func(opts *FetchCanceledAndClosedOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type CancelOrdersOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type CancelOrdersOptions func(opts *CancelOrdersOptionsStruct)

func WithCancelOrdersSymbol(symbol string) CancelOrdersOptions {
    return func(opts *CancelOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithCancelOrdersParams(params map[string]interface{}) CancelOrdersOptions {
    return func(opts *CancelOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMyDustTradesOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchMyDustTradesOptions func(opts *FetchMyDustTradesOptionsStruct)

func WithFetchMyDustTradesSymbol(symbol string) FetchMyDustTradesOptions {
    return func(opts *FetchMyDustTradesOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchMyDustTradesSince(since int64) FetchMyDustTradesOptions {
    return func(opts *FetchMyDustTradesOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchMyDustTradesLimit(limit int64) FetchMyDustTradesOptions {
    return func(opts *FetchMyDustTradesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchMyDustTradesParams(params map[string]interface{}) FetchMyDustTradesOptions {
    return func(opts *FetchMyDustTradesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransfersOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchTransfersOptions func(opts *FetchTransfersOptionsStruct)

func WithFetchTransfersCode(code string) FetchTransfersOptions {
    return func(opts *FetchTransfersOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchTransfersSince(since int64) FetchTransfersOptions {
    return func(opts *FetchTransfersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchTransfersLimit(limit int64) FetchTransfersOptions {
    return func(opts *FetchTransfersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchTransfersParams(params map[string]interface{}) FetchTransfersOptions {
    return func(opts *FetchTransfersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransactionFeesOptionsStruct struct {
    Codes *[]string
    Params *map[string]interface{}
}

type FetchTransactionFeesOptions func(opts *FetchTransactionFeesOptionsStruct)

func WithFetchTransactionFeesCodes(codes []string) FetchTransactionFeesOptions {
    return func(opts *FetchTransactionFeesOptionsStruct) {
        opts.Codes = &codes
    }
}


func WithFetchTransactionFeesParams(params map[string]interface{}) FetchTransactionFeesOptions {
    return func(opts *FetchTransactionFeesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTradingFeeOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTradingFeeOptions func(opts *FetchTradingFeeOptionsStruct)

func WithFetchTradingFeeParams(params map[string]interface{}) FetchTradingFeeOptions {
    return func(opts *FetchTradingFeeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchFundingRateOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchFundingRateOptions func(opts *FetchFundingRateOptionsStruct)

func WithFetchFundingRateParams(params map[string]interface{}) FetchFundingRateOptions {
    return func(opts *FetchFundingRateOptionsStruct) {
        opts.Params = &params
    }
}


type FetchFundingRateHistoryOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchFundingRateHistoryOptions func(opts *FetchFundingRateHistoryOptionsStruct)

func WithFetchFundingRateHistorySymbol(symbol string) FetchFundingRateHistoryOptions {
    return func(opts *FetchFundingRateHistoryOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchFundingRateHistorySince(since int64) FetchFundingRateHistoryOptions {
    return func(opts *FetchFundingRateHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchFundingRateHistoryLimit(limit int64) FetchFundingRateHistoryOptions {
    return func(opts *FetchFundingRateHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchFundingRateHistoryParams(params map[string]interface{}) FetchFundingRateHistoryOptions {
    return func(opts *FetchFundingRateHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPositionOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchPositionOptions func(opts *FetchPositionOptionsStruct)

func WithFetchPositionParams(params map[string]interface{}) FetchPositionOptions {
    return func(opts *FetchPositionOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOptionPositionsOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchOptionPositionsOptions func(opts *FetchOptionPositionsOptionsStruct)

func WithFetchOptionPositionsSymbols(symbols []string) FetchOptionPositionsOptions {
    return func(opts *FetchOptionPositionsOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchOptionPositionsParams(params map[string]interface{}) FetchOptionPositionsOptions {
    return func(opts *FetchOptionPositionsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchAccountPositionsOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchAccountPositionsOptions func(opts *FetchAccountPositionsOptionsStruct)

func WithFetchAccountPositionsSymbols(symbols []string) FetchAccountPositionsOptions {
    return func(opts *FetchAccountPositionsOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchAccountPositionsParams(params map[string]interface{}) FetchAccountPositionsOptions {
    return func(opts *FetchAccountPositionsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPositionsRiskOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchPositionsRiskOptions func(opts *FetchPositionsRiskOptionsStruct)

func WithFetchPositionsRiskSymbols(symbols []string) FetchPositionsRiskOptions {
    return func(opts *FetchPositionsRiskOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchPositionsRiskParams(params map[string]interface{}) FetchPositionsRiskOptions {
    return func(opts *FetchPositionsRiskOptionsStruct) {
        opts.Params = &params
    }
}


type SetPositionModeOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type SetPositionModeOptions func(opts *SetPositionModeOptionsStruct)

func WithSetPositionModeSymbol(symbol string) SetPositionModeOptions {
    return func(opts *SetPositionModeOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithSetPositionModeParams(params map[string]interface{}) SetPositionModeOptions {
    return func(opts *SetPositionModeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchSettlementHistoryOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchSettlementHistoryOptions func(opts *FetchSettlementHistoryOptionsStruct)

func WithFetchSettlementHistorySymbol(symbol string) FetchSettlementHistoryOptions {
    return func(opts *FetchSettlementHistoryOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchSettlementHistorySince(since int64) FetchSettlementHistoryOptions {
    return func(opts *FetchSettlementHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchSettlementHistoryLimit(limit int64) FetchSettlementHistoryOptions {
    return func(opts *FetchSettlementHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchSettlementHistoryParams(params map[string]interface{}) FetchSettlementHistoryOptions {
    return func(opts *FetchSettlementHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMySettlementHistoryOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchMySettlementHistoryOptions func(opts *FetchMySettlementHistoryOptionsStruct)

func WithFetchMySettlementHistorySymbol(symbol string) FetchMySettlementHistoryOptions {
    return func(opts *FetchMySettlementHistoryOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchMySettlementHistorySince(since int64) FetchMySettlementHistoryOptions {
    return func(opts *FetchMySettlementHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchMySettlementHistoryLimit(limit int64) FetchMySettlementHistoryOptions {
    return func(opts *FetchMySettlementHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchMySettlementHistoryParams(params map[string]interface{}) FetchMySettlementHistoryOptions {
    return func(opts *FetchMySettlementHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLedgerEntryOptionsStruct struct {
    Code *string
    Params *map[string]interface{}
}

type FetchLedgerEntryOptions func(opts *FetchLedgerEntryOptionsStruct)

func WithFetchLedgerEntryCode(code string) FetchLedgerEntryOptions {
    return func(opts *FetchLedgerEntryOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchLedgerEntryParams(params map[string]interface{}) FetchLedgerEntryOptions {
    return func(opts *FetchLedgerEntryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLedgerOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchLedgerOptions func(opts *FetchLedgerOptionsStruct)

func WithFetchLedgerCode(code string) FetchLedgerOptions {
    return func(opts *FetchLedgerOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchLedgerSince(since int64) FetchLedgerOptions {
    return func(opts *FetchLedgerOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchLedgerLimit(limit int64) FetchLedgerOptions {
    return func(opts *FetchLedgerOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchLedgerParams(params map[string]interface{}) FetchLedgerOptions {
    return func(opts *FetchLedgerOptionsStruct) {
        opts.Params = &params
    }
}


type FetchCrossBorrowRateOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchCrossBorrowRateOptions func(opts *FetchCrossBorrowRateOptionsStruct)

func WithFetchCrossBorrowRateParams(params map[string]interface{}) FetchCrossBorrowRateOptions {
    return func(opts *FetchCrossBorrowRateOptionsStruct) {
        opts.Params = &params
    }
}


type FetchIsolatedBorrowRateOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchIsolatedBorrowRateOptions func(opts *FetchIsolatedBorrowRateOptionsStruct)

func WithFetchIsolatedBorrowRateParams(params map[string]interface{}) FetchIsolatedBorrowRateOptions {
    return func(opts *FetchIsolatedBorrowRateOptionsStruct) {
        opts.Params = &params
    }
}


type FetchBorrowRateHistoryOptionsStruct struct {
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchBorrowRateHistoryOptions func(opts *FetchBorrowRateHistoryOptionsStruct)

func WithFetchBorrowRateHistorySince(since int64) FetchBorrowRateHistoryOptions {
    return func(opts *FetchBorrowRateHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchBorrowRateHistoryLimit(limit int64) FetchBorrowRateHistoryOptions {
    return func(opts *FetchBorrowRateHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchBorrowRateHistoryParams(params map[string]interface{}) FetchBorrowRateHistoryOptions {
    return func(opts *FetchBorrowRateHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type CreateGiftCodeOptionsStruct struct {
    Params *map[string]interface{}
}

type CreateGiftCodeOptions func(opts *CreateGiftCodeOptionsStruct)

func WithCreateGiftCodeParams(params map[string]interface{}) CreateGiftCodeOptions {
    return func(opts *CreateGiftCodeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchBorrowInterestOptionsStruct struct {
    Code *string
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchBorrowInterestOptions func(opts *FetchBorrowInterestOptionsStruct)

func WithFetchBorrowInterestCode(code string) FetchBorrowInterestOptions {
    return func(opts *FetchBorrowInterestOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchBorrowInterestSymbol(symbol string) FetchBorrowInterestOptions {
    return func(opts *FetchBorrowInterestOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchBorrowInterestSince(since int64) FetchBorrowInterestOptions {
    return func(opts *FetchBorrowInterestOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchBorrowInterestLimit(limit int64) FetchBorrowInterestOptions {
    return func(opts *FetchBorrowInterestOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchBorrowInterestParams(params map[string]interface{}) FetchBorrowInterestOptions {
    return func(opts *FetchBorrowInterestOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenInterestHistoryOptionsStruct struct {
    Timeframe *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOpenInterestHistoryOptions func(opts *FetchOpenInterestHistoryOptionsStruct)

func WithFetchOpenInterestHistoryTimeframe(timeframe string) FetchOpenInterestHistoryOptions {
    return func(opts *FetchOpenInterestHistoryOptionsStruct) {
        opts.Timeframe = &timeframe
    }
}


func WithFetchOpenInterestHistorySince(since int64) FetchOpenInterestHistoryOptions {
    return func(opts *FetchOpenInterestHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOpenInterestHistoryLimit(limit int64) FetchOpenInterestHistoryOptions {
    return func(opts *FetchOpenInterestHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOpenInterestHistoryParams(params map[string]interface{}) FetchOpenInterestHistoryOptions {
    return func(opts *FetchOpenInterestHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenInterestOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchOpenInterestOptions func(opts *FetchOpenInterestOptionsStruct)

func WithFetchOpenInterestParams(params map[string]interface{}) FetchOpenInterestOptions {
    return func(opts *FetchOpenInterestOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMyLiquidationsOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchMyLiquidationsOptions func(opts *FetchMyLiquidationsOptionsStruct)

func WithFetchMyLiquidationsSymbol(symbol string) FetchMyLiquidationsOptions {
    return func(opts *FetchMyLiquidationsOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchMyLiquidationsSince(since int64) FetchMyLiquidationsOptions {
    return func(opts *FetchMyLiquidationsOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchMyLiquidationsLimit(limit int64) FetchMyLiquidationsOptions {
    return func(opts *FetchMyLiquidationsOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchMyLiquidationsParams(params map[string]interface{}) FetchMyLiquidationsOptions {
    return func(opts *FetchMyLiquidationsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchGreeksOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchGreeksOptions func(opts *FetchGreeksOptionsStruct)

func WithFetchGreeksParams(params map[string]interface{}) FetchGreeksOptions {
    return func(opts *FetchGreeksOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTradingLimitsOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchTradingLimitsOptions func(opts *FetchTradingLimitsOptionsStruct)

func WithFetchTradingLimitsSymbols(symbols []string) FetchTradingLimitsOptions {
    return func(opts *FetchTradingLimitsOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchTradingLimitsParams(params map[string]interface{}) FetchTradingLimitsOptions {
    return func(opts *FetchTradingLimitsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPositionModeOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchPositionModeOptions func(opts *FetchPositionModeOptionsStruct)

func WithFetchPositionModeSymbol(symbol string) FetchPositionModeOptions {
    return func(opts *FetchPositionModeOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchPositionModeParams(params map[string]interface{}) FetchPositionModeOptions {
    return func(opts *FetchPositionModeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarginModeOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchMarginModeOptions func(opts *FetchMarginModeOptionsStruct)

func WithFetchMarginModeParams(params map[string]interface{}) FetchMarginModeOptions {
    return func(opts *FetchMarginModeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOptionOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchOptionOptions func(opts *FetchOptionOptionsStruct)

func WithFetchOptionParams(params map[string]interface{}) FetchOptionOptions {
    return func(opts *FetchOptionOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarginAdjustmentHistoryOptionsStruct struct {
    Symbol *string
    Type *string
    Since *float64
    Limit *float64
    Params *map[string]interface{}
}

type FetchMarginAdjustmentHistoryOptions func(opts *FetchMarginAdjustmentHistoryOptionsStruct)

func WithFetchMarginAdjustmentHistorySymbol(symbol string) FetchMarginAdjustmentHistoryOptions {
    return func(opts *FetchMarginAdjustmentHistoryOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchMarginAdjustmentHistoryType(typeVar string) FetchMarginAdjustmentHistoryOptions {
    return func(opts *FetchMarginAdjustmentHistoryOptionsStruct) {
        opts.Type = &typeVar
    }
}


func WithFetchMarginAdjustmentHistorySince(since float64) FetchMarginAdjustmentHistoryOptions {
    return func(opts *FetchMarginAdjustmentHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchMarginAdjustmentHistoryLimit(limit float64) FetchMarginAdjustmentHistoryOptions {
    return func(opts *FetchMarginAdjustmentHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchMarginAdjustmentHistoryParams(params map[string]interface{}) FetchMarginAdjustmentHistoryOptions {
    return func(opts *FetchMarginAdjustmentHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchConvertQuoteOptionsStruct struct {
    Amount *float64
    Params *map[string]interface{}
}

type FetchConvertQuoteOptions func(opts *FetchConvertQuoteOptionsStruct)

func WithFetchConvertQuoteAmount(amount float64) FetchConvertQuoteOptions {
    return func(opts *FetchConvertQuoteOptionsStruct) {
        opts.Amount = &amount
    }
}


func WithFetchConvertQuoteParams(params map[string]interface{}) FetchConvertQuoteOptions {
    return func(opts *FetchConvertQuoteOptionsStruct) {
        opts.Params = &params
    }
}


type CreateConvertTradeOptionsStruct struct {
    Amount *float64
    Params *map[string]interface{}
}

type CreateConvertTradeOptions func(opts *CreateConvertTradeOptionsStruct)

func WithCreateConvertTradeAmount(amount float64) CreateConvertTradeOptions {
    return func(opts *CreateConvertTradeOptionsStruct) {
        opts.Amount = &amount
    }
}


func WithCreateConvertTradeParams(params map[string]interface{}) CreateConvertTradeOptions {
    return func(opts *CreateConvertTradeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchConvertTradeOptionsStruct struct {
    Code *string
    Params *map[string]interface{}
}

type FetchConvertTradeOptions func(opts *FetchConvertTradeOptionsStruct)

func WithFetchConvertTradeCode(code string) FetchConvertTradeOptions {
    return func(opts *FetchConvertTradeOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchConvertTradeParams(params map[string]interface{}) FetchConvertTradeOptions {
    return func(opts *FetchConvertTradeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchConvertTradeHistoryOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchConvertTradeHistoryOptions func(opts *FetchConvertTradeHistoryOptionsStruct)

func WithFetchConvertTradeHistoryCode(code string) FetchConvertTradeHistoryOptions {
    return func(opts *FetchConvertTradeHistoryOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchConvertTradeHistorySince(since int64) FetchConvertTradeHistoryOptions {
    return func(opts *FetchConvertTradeHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchConvertTradeHistoryLimit(limit int64) FetchConvertTradeHistoryOptions {
    return func(opts *FetchConvertTradeHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchConvertTradeHistoryParams(params map[string]interface{}) FetchConvertTradeHistoryOptions {
    return func(opts *FetchConvertTradeHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchFundingIntervalsOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchFundingIntervalsOptions func(opts *FetchFundingIntervalsOptionsStruct)

func WithFetchFundingIntervalsSymbols(symbols []string) FetchFundingIntervalsOptions {
    return func(opts *FetchFundingIntervalsOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchFundingIntervalsParams(params map[string]interface{}) FetchFundingIntervalsOptions {
    return func(opts *FetchFundingIntervalsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLongShortRatioHistoryOptionsStruct struct {
    Symbol *string
    Timeframe *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchLongShortRatioHistoryOptions func(opts *FetchLongShortRatioHistoryOptionsStruct)

func WithFetchLongShortRatioHistorySymbol(symbol string) FetchLongShortRatioHistoryOptions {
    return func(opts *FetchLongShortRatioHistoryOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchLongShortRatioHistoryTimeframe(timeframe string) FetchLongShortRatioHistoryOptions {
    return func(opts *FetchLongShortRatioHistoryOptionsStruct) {
        opts.Timeframe = &timeframe
    }
}


func WithFetchLongShortRatioHistorySince(since int64) FetchLongShortRatioHistoryOptions {
    return func(opts *FetchLongShortRatioHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchLongShortRatioHistoryLimit(limit int64) FetchLongShortRatioHistoryOptions {
    return func(opts *FetchLongShortRatioHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchLongShortRatioHistoryParams(params map[string]interface{}) FetchLongShortRatioHistoryOptions {
    return func(opts *FetchLongShortRatioHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type TransferInOptionsStruct struct {
    Params *map[string]interface{}
}

type TransferInOptions func(opts *TransferInOptionsStruct)

func WithTransferInParams(params map[string]interface{}) TransferInOptions {
    return func(opts *TransferInOptionsStruct) {
        opts.Params = &params
    }
}


type TransferOutOptionsStruct struct {
    Params *map[string]interface{}
}

type TransferOutOptions func(opts *TransferOutOptionsStruct)

func WithTransferOutParams(params map[string]interface{}) TransferOutOptions {
    return func(opts *TransferOutOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPositionHistoryOptionsStruct struct {
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchPositionHistoryOptions func(opts *FetchPositionHistoryOptionsStruct)

func WithFetchPositionHistorySince(since int64) FetchPositionHistoryOptions {
    return func(opts *FetchPositionHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchPositionHistoryLimit(limit int64) FetchPositionHistoryOptions {
    return func(opts *FetchPositionHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchPositionHistoryParams(params map[string]interface{}) FetchPositionHistoryOptions {
    return func(opts *FetchPositionHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type CancelAllOrdersAfterOptionsStruct struct {
    Params *map[string]interface{}
}

type CancelAllOrdersAfterOptions func(opts *CancelAllOrdersAfterOptionsStruct)

func WithCancelAllOrdersAfterParams(params map[string]interface{}) CancelAllOrdersAfterOptions {
    return func(opts *CancelAllOrdersAfterOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositAddressesByNetworkOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchDepositAddressesByNetworkOptions func(opts *FetchDepositAddressesByNetworkOptionsStruct)

func WithFetchDepositAddressesByNetworkParams(params map[string]interface{}) FetchDepositAddressesByNetworkOptions {
    return func(opts *FetchDepositAddressesByNetworkOptionsStruct) {
        opts.Params = &params
    }
}


type SetMarginOptionsStruct struct {
    Params *map[string]interface{}
}

type SetMarginOptions func(opts *SetMarginOptionsStruct)

func WithSetMarginParams(params map[string]interface{}) SetMarginOptions {
    return func(opts *SetMarginOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLeverageOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchLeverageOptions func(opts *FetchLeverageOptionsStruct)

func WithFetchLeverageParams(params map[string]interface{}) FetchLeverageOptions {
    return func(opts *FetchLeverageOptionsStruct) {
        opts.Params = &params
    }
}


type FetchClosedOrderOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchClosedOrderOptions func(opts *FetchClosedOrderOptionsStruct)

func WithFetchClosedOrderSymbol(symbol string) FetchClosedOrderOptions {
    return func(opts *FetchClosedOrderOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchClosedOrderParams(params map[string]interface{}) FetchClosedOrderOptions {
    return func(opts *FetchClosedOrderOptionsStruct) {
        opts.Params = &params
    }
}


type CreateDepositAddressOptionsStruct struct {
    Params *map[string]interface{}
}

type CreateDepositAddressOptions func(opts *CreateDepositAddressOptionsStruct)

func WithCreateDepositAddressParams(params map[string]interface{}) CreateDepositAddressOptions {
    return func(opts *CreateDepositAddressOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenInterestsOptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchOpenInterestsOptions func(opts *FetchOpenInterestsOptionsStruct)

func WithFetchOpenInterestsSymbols(symbols []string) FetchOpenInterestsOptions {
    return func(opts *FetchOpenInterestsOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchOpenInterestsParams(params map[string]interface{}) FetchOpenInterestsOptions {
    return func(opts *FetchOpenInterestsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLiquidationsOptionsStruct struct {
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchLiquidationsOptions func(opts *FetchLiquidationsOptionsStruct)

func WithFetchLiquidationsSince(since int64) FetchLiquidationsOptions {
    return func(opts *FetchLiquidationsOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchLiquidationsLimit(limit int64) FetchLiquidationsOptions {
    return func(opts *FetchLiquidationsOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchLiquidationsParams(params map[string]interface{}) FetchLiquidationsOptions {
    return func(opts *FetchLiquidationsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarketLeverageTiersOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchMarketLeverageTiersOptions func(opts *FetchMarketLeverageTiersOptionsStruct)

func WithFetchMarketLeverageTiersParams(params map[string]interface{}) FetchMarketLeverageTiersOptions {
    return func(opts *FetchMarketLeverageTiersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPositionsHistoryOptionsStruct struct {
    Symbols *[]string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchPositionsHistoryOptions func(opts *FetchPositionsHistoryOptionsStruct)

func WithFetchPositionsHistorySymbols(symbols []string) FetchPositionsHistoryOptions {
    return func(opts *FetchPositionsHistoryOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchPositionsHistorySince(since int64) FetchPositionsHistoryOptions {
    return func(opts *FetchPositionsHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchPositionsHistoryLimit(limit int64) FetchPositionsHistoryOptions {
    return func(opts *FetchPositionsHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchPositionsHistoryParams(params map[string]interface{}) FetchPositionsHistoryOptions {
    return func(opts *FetchPositionsHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchFundingIntervalOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchFundingIntervalOptions func(opts *FetchFundingIntervalOptionsStruct)

func WithFetchFundingIntervalParams(params map[string]interface{}) FetchFundingIntervalOptions {
    return func(opts *FetchFundingIntervalOptionsStruct) {
        opts.Params = &params
    }
}


type CancelUnifiedOrderOptionsStruct struct {
    Params *map[string]interface{}
}

type CancelUnifiedOrderOptions func(opts *CancelUnifiedOrderOptionsStruct)

func WithCancelUnifiedOrderParams(params map[string]interface{}) CancelUnifiedOrderOptions {
    return func(opts *CancelUnifiedOrderOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransactionFeeOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTransactionFeeOptions func(opts *FetchTransactionFeeOptionsStruct)

func WithFetchTransactionFeeParams(params map[string]interface{}) FetchTransactionFeeOptions {
    return func(opts *FetchTransactionFeeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositWithdrawFeeOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchDepositWithdrawFeeOptions func(opts *FetchDepositWithdrawFeeOptionsStruct)

func WithFetchDepositWithdrawFeeParams(params map[string]interface{}) FetchDepositWithdrawFeeOptions {
    return func(opts *FetchDepositWithdrawFeeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersByStatusOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrdersByStatusOptions func(opts *FetchOrdersByStatusOptionsStruct)

func WithFetchOrdersByStatusSymbol(symbol string) FetchOrdersByStatusOptions {
    return func(opts *FetchOrdersByStatusOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersByStatusSince(since int64) FetchOrdersByStatusOptions {
    return func(opts *FetchOrdersByStatusOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrdersByStatusLimit(limit int64) FetchOrdersByStatusOptions {
    return func(opts *FetchOrdersByStatusOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrdersByStatusParams(params map[string]interface{}) FetchOrdersByStatusOptions {
    return func(opts *FetchOrdersByStatusOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransactionsByTypeOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchTransactionsByTypeOptions func(opts *FetchTransactionsByTypeOptionsStruct)

func WithFetchTransactionsByTypeCode(code string) FetchTransactionsByTypeOptions {
    return func(opts *FetchTransactionsByTypeOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchTransactionsByTypeSince(since int64) FetchTransactionsByTypeOptions {
    return func(opts *FetchTransactionsByTypeOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchTransactionsByTypeLimit(limit int64) FetchTransactionsByTypeOptions {
    return func(opts *FetchTransactionsByTypeOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchTransactionsByTypeParams(params map[string]interface{}) FetchTransactionsByTypeOptions {
    return func(opts *FetchTransactionsByTypeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositOptionsStruct struct {
    Code *string
    Params *map[string]interface{}
}

type FetchDepositOptions func(opts *FetchDepositOptionsStruct)

func WithFetchDepositCode(code string) FetchDepositOptions {
    return func(opts *FetchDepositOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchDepositParams(params map[string]interface{}) FetchDepositOptions {
    return func(opts *FetchDepositOptionsStruct) {
        opts.Params = &params
    }
}


type FetchWithdrawalOptionsStruct struct {
    Code *string
    Params *map[string]interface{}
}

type FetchWithdrawalOptions func(opts *FetchWithdrawalOptionsStruct)

func WithFetchWithdrawalCode(code string) FetchWithdrawalOptions {
    return func(opts *FetchWithdrawalOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchWithdrawalParams(params map[string]interface{}) FetchWithdrawalOptions {
    return func(opts *FetchWithdrawalOptionsStruct) {
        opts.Params = &params
    }
}


type FetchWithdrawAddressesOptionsStruct struct {
    Note *interface{}
    NetworkCode *interface{}
    Params *map[string]interface{}
}

type FetchWithdrawAddressesOptions func(opts *FetchWithdrawAddressesOptionsStruct)

func WithFetchWithdrawAddressesNote(note interface{}) FetchWithdrawAddressesOptions {
    return func(opts *FetchWithdrawAddressesOptionsStruct) {
        opts.Note = &note
    }
}


func WithFetchWithdrawAddressesNetworkCode(networkCode interface{}) FetchWithdrawAddressesOptions {
    return func(opts *FetchWithdrawAddressesOptionsStruct) {
        opts.NetworkCode = &networkCode
    }
}


func WithFetchWithdrawAddressesParams(params map[string]interface{}) FetchWithdrawAddressesOptions {
    return func(opts *FetchWithdrawAddressesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrderStatusOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchOrderStatusOptions func(opts *FetchOrderStatusOptionsStruct)

func WithFetchOrderStatusSymbol(symbol string) FetchOrderStatusOptions {
    return func(opts *FetchOrderStatusOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrderStatusParams(params map[string]interface{}) FetchOrderStatusOptions {
    return func(opts *FetchOrderStatusOptionsStruct) {
        opts.Params = &params
    }
}


type FetchL3OrderBookOptionsStruct struct {
    Limit *int64
    Params *map[string]interface{}
}

type FetchL3OrderBookOptions func(opts *FetchL3OrderBookOptionsStruct)

func WithFetchL3OrderBookLimit(limit int64) FetchL3OrderBookOptions {
    return func(opts *FetchL3OrderBookOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchL3OrderBookParams(params map[string]interface{}) FetchL3OrderBookOptions {
    return func(opts *FetchL3OrderBookOptionsStruct) {
        opts.Params = &params
    }
}


type FetchL2OrderBookOptionsStruct struct {
    Limit *int64
    Params *map[string]interface{}
}

type FetchL2OrderBookOptions func(opts *FetchL2OrderBookOptionsStruct)

func WithFetchL2OrderBookLimit(limit int64) FetchL2OrderBookOptions {
    return func(opts *FetchL2OrderBookOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchL2OrderBookParams(params map[string]interface{}) FetchL2OrderBookOptions {
    return func(opts *FetchL2OrderBookOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersByStateOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrdersByStateOptions func(opts *FetchOrdersByStateOptionsStruct)

func WithFetchOrdersByStateSymbol(symbol string) FetchOrdersByStateOptions {
    return func(opts *FetchOrdersByStateOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersByStateSince(since int64) FetchOrdersByStateOptions {
    return func(opts *FetchOrdersByStateOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrdersByStateLimit(limit int64) FetchOrdersByStateOptions {
    return func(opts *FetchOrdersByStateOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrdersByStateParams(params map[string]interface{}) FetchOrdersByStateOptions {
    return func(opts *FetchOrdersByStateOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersByTypeOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrdersByTypeOptions func(opts *FetchOrdersByTypeOptionsStruct)

func WithFetchOrdersByTypeSymbol(symbol string) FetchOrdersByTypeOptions {
    return func(opts *FetchOrdersByTypeOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersByTypeSince(since int64) FetchOrdersByTypeOptions {
    return func(opts *FetchOrdersByTypeOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrdersByTypeLimit(limit int64) FetchOrdersByTypeOptions {
    return func(opts *FetchOrdersByTypeOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrdersByTypeParams(params map[string]interface{}) FetchOrdersByTypeOptions {
    return func(opts *FetchOrdersByTypeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransactionsWithMethodOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchTransactionsWithMethodOptions func(opts *FetchTransactionsWithMethodOptionsStruct)

func WithFetchTransactionsWithMethodCode(code string) FetchTransactionsWithMethodOptions {
    return func(opts *FetchTransactionsWithMethodOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchTransactionsWithMethodSince(since int64) FetchTransactionsWithMethodOptions {
    return func(opts *FetchTransactionsWithMethodOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchTransactionsWithMethodLimit(limit int64) FetchTransactionsWithMethodOptions {
    return func(opts *FetchTransactionsWithMethodOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchTransactionsWithMethodParams(params map[string]interface{}) FetchTransactionsWithMethodOptions {
    return func(opts *FetchTransactionsWithMethodOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTicker2OptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTicker2Options func(opts *FetchTicker2OptionsStruct)

func WithFetchTicker2Params(params map[string]interface{}) FetchTicker2Options {
    return func(opts *FetchTicker2OptionsStruct) {
        opts.Params = &params
    }
}


type CancelOrdersForSymbolsOptionsStruct struct {
    Params *map[string]interface{}
}

type CancelOrdersForSymbolsOptions func(opts *CancelOrdersForSymbolsOptionsStruct)

func WithCancelOrdersForSymbolsParams(params map[string]interface{}) CancelOrdersForSymbolsOptions {
    return func(opts *CancelOrdersForSymbolsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrderClassicOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchOrderClassicOptions func(opts *FetchOrderClassicOptionsStruct)

func WithFetchOrderClassicSymbol(symbol string) FetchOrderClassicOptions {
    return func(opts *FetchOrderClassicOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrderClassicParams(params map[string]interface{}) FetchOrderClassicOptions {
    return func(opts *FetchOrderClassicOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersClassicOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrdersClassicOptions func(opts *FetchOrdersClassicOptionsStruct)

func WithFetchOrdersClassicSymbol(symbol string) FetchOrdersClassicOptions {
    return func(opts *FetchOrdersClassicOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersClassicSince(since int64) FetchOrdersClassicOptions {
    return func(opts *FetchOrdersClassicOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrdersClassicLimit(limit int64) FetchOrdersClassicOptions {
    return func(opts *FetchOrdersClassicOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrdersClassicParams(params map[string]interface{}) FetchOrdersClassicOptions {
    return func(opts *FetchOrdersClassicOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDerivativesOpenInterestHistoryOptionsStruct struct {
    Timeframe *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchDerivativesOpenInterestHistoryOptions func(opts *FetchDerivativesOpenInterestHistoryOptionsStruct)

func WithFetchDerivativesOpenInterestHistoryTimeframe(timeframe string) FetchDerivativesOpenInterestHistoryOptions {
    return func(opts *FetchDerivativesOpenInterestHistoryOptionsStruct) {
        opts.Timeframe = &timeframe
    }
}


func WithFetchDerivativesOpenInterestHistorySince(since int64) FetchDerivativesOpenInterestHistoryOptions {
    return func(opts *FetchDerivativesOpenInterestHistoryOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchDerivativesOpenInterestHistoryLimit(limit int64) FetchDerivativesOpenInterestHistoryOptions {
    return func(opts *FetchDerivativesOpenInterestHistoryOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchDerivativesOpenInterestHistoryParams(params map[string]interface{}) FetchDerivativesOpenInterestHistoryOptions {
    return func(opts *FetchDerivativesOpenInterestHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDerivativesMarketLeverageTiersOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchDerivativesMarketLeverageTiersOptions func(opts *FetchDerivativesMarketLeverageTiersOptionsStruct)

func WithFetchDerivativesMarketLeverageTiersParams(params map[string]interface{}) FetchDerivativesMarketLeverageTiersOptions {
    return func(opts *FetchDerivativesMarketLeverageTiersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchVolatilityHistoryOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchVolatilityHistoryOptions func(opts *FetchVolatilityHistoryOptionsStruct)

func WithFetchVolatilityHistoryParams(params map[string]interface{}) FetchVolatilityHistoryOptions {
    return func(opts *FetchVolatilityHistoryOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOptionChainOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchOptionChainOptions func(opts *FetchOptionChainOptionsStruct)

func WithFetchOptionChainParams(params map[string]interface{}) FetchOptionChainOptions {
    return func(opts *FetchOptionChainOptionsStruct) {
        opts.Params = &params
    }
}


type TransferBetweenMainAndSubAccountOptionsStruct struct {
    Params *map[string]interface{}
}

type TransferBetweenMainAndSubAccountOptions func(opts *TransferBetweenMainAndSubAccountOptionsStruct)

func WithTransferBetweenMainAndSubAccountParams(params map[string]interface{}) TransferBetweenMainAndSubAccountOptions {
    return func(opts *TransferBetweenMainAndSubAccountOptionsStruct) {
        opts.Params = &params
    }
}


type TransferBetweenSubAccountsOptionsStruct struct {
    Params *map[string]interface{}
}

type TransferBetweenSubAccountsOptions func(opts *TransferBetweenSubAccountsOptionsStruct)

func WithTransferBetweenSubAccountsParams(params map[string]interface{}) TransferBetweenSubAccountsOptions {
    return func(opts *TransferBetweenSubAccountsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMySellsOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchMySellsOptions func(opts *FetchMySellsOptionsStruct)

func WithFetchMySellsSymbol(symbol string) FetchMySellsOptions {
    return func(opts *FetchMySellsOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchMySellsSince(since int64) FetchMySellsOptions {
    return func(opts *FetchMySellsOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchMySellsLimit(limit int64) FetchMySellsOptions {
    return func(opts *FetchMySellsOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchMySellsParams(params map[string]interface{}) FetchMySellsOptions {
    return func(opts *FetchMySellsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMyBuysOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchMyBuysOptions func(opts *FetchMyBuysOptionsStruct)

func WithFetchMyBuysSymbol(symbol string) FetchMyBuysOptions {
    return func(opts *FetchMyBuysOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchMyBuysSince(since int64) FetchMyBuysOptions {
    return func(opts *FetchMyBuysOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchMyBuysLimit(limit int64) FetchMyBuysOptions {
    return func(opts *FetchMyBuysOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchMyBuysParams(params map[string]interface{}) FetchMyBuysOptions {
    return func(opts *FetchMyBuysOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTickersV2OptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchTickersV2Options func(opts *FetchTickersV2OptionsStruct)

func WithFetchTickersV2Symbols(symbols []string) FetchTickersV2Options {
    return func(opts *FetchTickersV2OptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchTickersV2Params(params map[string]interface{}) FetchTickersV2Options {
    return func(opts *FetchTickersV2OptionsStruct) {
        opts.Params = &params
    }
}


type FetchTickersV3OptionsStruct struct {
    Symbols *[]string
    Params *map[string]interface{}
}

type FetchTickersV3Options func(opts *FetchTickersV3OptionsStruct)

func WithFetchTickersV3Symbols(symbols []string) FetchTickersV3Options {
    return func(opts *FetchTickersV3OptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchTickersV3Params(params map[string]interface{}) FetchTickersV3Options {
    return func(opts *FetchTickersV3OptionsStruct) {
        opts.Params = &params
    }
}


type FetchTickerV2OptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTickerV2Options func(opts *FetchTickerV2OptionsStruct)

func WithFetchTickerV2Params(params map[string]interface{}) FetchTickerV2Options {
    return func(opts *FetchTickerV2OptionsStruct) {
        opts.Params = &params
    }
}


type FetchTickerV3OptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTickerV3Options func(opts *FetchTickerV3OptionsStruct)

func WithFetchTickerV3Params(params map[string]interface{}) FetchTickerV3Options {
    return func(opts *FetchTickerV3OptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositMethodIdOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchDepositMethodIdOptions func(opts *FetchDepositMethodIdOptionsStruct)

func WithFetchDepositMethodIdParams(params map[string]interface{}) FetchDepositMethodIdOptions {
    return func(opts *FetchDepositMethodIdOptionsStruct) {
        opts.Params = &params
    }
}


type CreateOrderWithTakeProfitAndStopLossOptionsStruct struct {
    Price *float64
    TakeProfit *float64
    StopLoss *float64
    Params *map[string]interface{}
}

type CreateOrderWithTakeProfitAndStopLossOptions func(opts *CreateOrderWithTakeProfitAndStopLossOptionsStruct)

func WithCreateOrderWithTakeProfitAndStopLossPrice(price float64) CreateOrderWithTakeProfitAndStopLossOptions {
    return func(opts *CreateOrderWithTakeProfitAndStopLossOptionsStruct) {
        opts.Price = &price
    }
}


func WithCreateOrderWithTakeProfitAndStopLossTakeProfit(takeProfit float64) CreateOrderWithTakeProfitAndStopLossOptions {
    return func(opts *CreateOrderWithTakeProfitAndStopLossOptionsStruct) {
        opts.TakeProfit = &takeProfit
    }
}


func WithCreateOrderWithTakeProfitAndStopLossStopLoss(stopLoss float64) CreateOrderWithTakeProfitAndStopLossOptions {
    return func(opts *CreateOrderWithTakeProfitAndStopLossOptionsStruct) {
        opts.StopLoss = &stopLoss
    }
}


func WithCreateOrderWithTakeProfitAndStopLossParams(params map[string]interface{}) CreateOrderWithTakeProfitAndStopLossOptions {
    return func(opts *CreateOrderWithTakeProfitAndStopLossOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenSpotOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOpenSpotOrdersOptions func(opts *FetchOpenSpotOrdersOptionsStruct)

func WithFetchOpenSpotOrdersSymbol(symbol string) FetchOpenSpotOrdersOptions {
    return func(opts *FetchOpenSpotOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOpenSpotOrdersSince(since int64) FetchOpenSpotOrdersOptions {
    return func(opts *FetchOpenSpotOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOpenSpotOrdersLimit(limit int64) FetchOpenSpotOrdersOptions {
    return func(opts *FetchOpenSpotOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOpenSpotOrdersParams(params map[string]interface{}) FetchOpenSpotOrdersOptions {
    return func(opts *FetchOpenSpotOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenSwapOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOpenSwapOrdersOptions func(opts *FetchOpenSwapOrdersOptionsStruct)

func WithFetchOpenSwapOrdersSymbol(symbol string) FetchOpenSwapOrdersOptions {
    return func(opts *FetchOpenSwapOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOpenSwapOrdersSince(since int64) FetchOpenSwapOrdersOptions {
    return func(opts *FetchOpenSwapOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOpenSwapOrdersLimit(limit int64) FetchOpenSwapOrdersOptions {
    return func(opts *FetchOpenSwapOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOpenSwapOrdersParams(params map[string]interface{}) FetchOpenSwapOrdersOptions {
    return func(opts *FetchOpenSwapOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchCanceledAndClosedSpotOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchCanceledAndClosedSpotOrdersOptions func(opts *FetchCanceledAndClosedSpotOrdersOptionsStruct)

func WithFetchCanceledAndClosedSpotOrdersSymbol(symbol string) FetchCanceledAndClosedSpotOrdersOptions {
    return func(opts *FetchCanceledAndClosedSpotOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchCanceledAndClosedSpotOrdersSince(since int64) FetchCanceledAndClosedSpotOrdersOptions {
    return func(opts *FetchCanceledAndClosedSpotOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchCanceledAndClosedSpotOrdersLimit(limit int64) FetchCanceledAndClosedSpotOrdersOptions {
    return func(opts *FetchCanceledAndClosedSpotOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchCanceledAndClosedSpotOrdersParams(params map[string]interface{}) FetchCanceledAndClosedSpotOrdersOptions {
    return func(opts *FetchCanceledAndClosedSpotOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchCanceledAndClosedSwapOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchCanceledAndClosedSwapOrdersOptions func(opts *FetchCanceledAndClosedSwapOrdersOptionsStruct)

func WithFetchCanceledAndClosedSwapOrdersSymbol(symbol string) FetchCanceledAndClosedSwapOrdersOptions {
    return func(opts *FetchCanceledAndClosedSwapOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchCanceledAndClosedSwapOrdersSince(since int64) FetchCanceledAndClosedSwapOrdersOptions {
    return func(opts *FetchCanceledAndClosedSwapOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchCanceledAndClosedSwapOrdersLimit(limit int64) FetchCanceledAndClosedSwapOrdersOptions {
    return func(opts *FetchCanceledAndClosedSwapOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchCanceledAndClosedSwapOrdersParams(params map[string]interface{}) FetchCanceledAndClosedSwapOrdersOptions {
    return func(opts *FetchCanceledAndClosedSwapOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPositionsForSymbolOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchPositionsForSymbolOptions func(opts *FetchPositionsForSymbolOptionsStruct)

func WithFetchPositionsForSymbolParams(params map[string]interface{}) FetchPositionsForSymbolOptions {
    return func(opts *FetchPositionsForSymbolOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositAddressesOptionsStruct struct {
    Codes *[]string
    Params *map[string]interface{}
}

type FetchDepositAddressesOptions func(opts *FetchDepositAddressesOptionsStruct)

func WithFetchDepositAddressesCodes(codes []string) FetchDepositAddressesOptions {
    return func(opts *FetchDepositAddressesOptionsStruct) {
        opts.Codes = &codes
    }
}


func WithFetchDepositAddressesParams(params map[string]interface{}) FetchDepositAddressesOptions {
    return func(opts *FetchDepositAddressesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransactionsByMethodOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchTransactionsByMethodOptions func(opts *FetchTransactionsByMethodOptionsStruct)

func WithFetchTransactionsByMethodCode(code string) FetchTransactionsByMethodOptions {
    return func(opts *FetchTransactionsByMethodOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchTransactionsByMethodSince(since int64) FetchTransactionsByMethodOptions {
    return func(opts *FetchTransactionsByMethodOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchTransactionsByMethodLimit(limit int64) FetchTransactionsByMethodOptions {
    return func(opts *FetchTransactionsByMethodOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchTransactionsByMethodParams(params map[string]interface{}) FetchTransactionsByMethodOptions {
    return func(opts *FetchTransactionsByMethodOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersWithMethodOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrdersWithMethodOptions func(opts *FetchOrdersWithMethodOptionsStruct)

func WithFetchOrdersWithMethodSymbol(symbol string) FetchOrdersWithMethodOptions {
    return func(opts *FetchOrdersWithMethodOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersWithMethodSince(since int64) FetchOrdersWithMethodOptions {
    return func(opts *FetchOrdersWithMethodOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrdersWithMethodLimit(limit int64) FetchOrdersWithMethodOptions {
    return func(opts *FetchOrdersWithMethodOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrdersWithMethodParams(params map[string]interface{}) FetchOrdersWithMethodOptions {
    return func(opts *FetchOrdersWithMethodOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrderBooksOptionsStruct struct {
    Symbols *[]string
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrderBooksOptions func(opts *FetchOrderBooksOptionsStruct)

func WithFetchOrderBooksSymbols(symbols []string) FetchOrderBooksOptions {
    return func(opts *FetchOrderBooksOptionsStruct) {
        opts.Symbols = &symbols
    }
}


func WithFetchOrderBooksLimit(limit int64) FetchOrderBooksOptions {
    return func(opts *FetchOrderBooksOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrderBooksParams(params map[string]interface{}) FetchOrderBooksOptions {
    return func(opts *FetchOrderBooksOptionsStruct) {
        opts.Params = &params
    }
}


type FetchNetworkDepositAddressOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchNetworkDepositAddressOptions func(opts *FetchNetworkDepositAddressOptionsStruct)

func WithFetchNetworkDepositAddressParams(params map[string]interface{}) FetchNetworkDepositAddressOptions {
    return func(opts *FetchNetworkDepositAddressOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOptionOHLCVOptionsStruct struct {
    Timeframe *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOptionOHLCVOptions func(opts *FetchOptionOHLCVOptionsStruct)

func WithFetchOptionOHLCVTimeframe(timeframe string) FetchOptionOHLCVOptions {
    return func(opts *FetchOptionOHLCVOptionsStruct) {
        opts.Timeframe = &timeframe
    }
}


func WithFetchOptionOHLCVSince(since int64) FetchOptionOHLCVOptions {
    return func(opts *FetchOptionOHLCVOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOptionOHLCVLimit(limit int64) FetchOptionOHLCVOptions {
    return func(opts *FetchOptionOHLCVOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOptionOHLCVParams(params map[string]interface{}) FetchOptionOHLCVOptions {
    return func(opts *FetchOptionOHLCVOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTickerV1OptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTickerV1Options func(opts *FetchTickerV1OptionsStruct)

func WithFetchTickerV1Params(params map[string]interface{}) FetchTickerV1Options {
    return func(opts *FetchTickerV1OptionsStruct) {
        opts.Params = &params
    }
}


type FetchTickerV1AndV2OptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTickerV1AndV2Options func(opts *FetchTickerV1AndV2OptionsStruct)

func WithFetchTickerV1AndV2Params(params map[string]interface{}) FetchTickerV1AndV2Options {
    return func(opts *FetchTickerV1AndV2OptionsStruct) {
        opts.Params = &params
    }
}


type FetchTradingLimitsByIdOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTradingLimitsByIdOptions func(opts *FetchTradingLimitsByIdOptionsStruct)

func WithFetchTradingLimitsByIdParams(params map[string]interface{}) FetchTradingLimitsByIdOptions {
    return func(opts *FetchTradingLimitsByIdOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarketsByTypeAndSubTypeOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchMarketsByTypeAndSubTypeOptions func(opts *FetchMarketsByTypeAndSubTypeOptionsStruct)

func WithFetchMarketsByTypeAndSubTypeParams(params map[string]interface{}) FetchMarketsByTypeAndSubTypeOptions {
    return func(opts *FetchMarketsByTypeAndSubTypeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchSpotOrderTradesOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchSpotOrderTradesOptions func(opts *FetchSpotOrderTradesOptionsStruct)

func WithFetchSpotOrderTradesSymbol(symbol string) FetchSpotOrderTradesOptions {
    return func(opts *FetchSpotOrderTradesOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchSpotOrderTradesSince(since int64) FetchSpotOrderTradesOptions {
    return func(opts *FetchSpotOrderTradesOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchSpotOrderTradesLimit(limit int64) FetchSpotOrderTradesOptions {
    return func(opts *FetchSpotOrderTradesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchSpotOrderTradesParams(params map[string]interface{}) FetchSpotOrderTradesOptions {
    return func(opts *FetchSpotOrderTradesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchAccountIdByTypeOptionsStruct struct {
    MarginMode *string
    Symbol *string
    Params *map[string]interface{}
}

type FetchAccountIdByTypeOptions func(opts *FetchAccountIdByTypeOptionsStruct)

func WithFetchAccountIdByTypeMarginMode(marginMode string) FetchAccountIdByTypeOptions {
    return func(opts *FetchAccountIdByTypeOptionsStruct) {
        opts.MarginMode = &marginMode
    }
}


func WithFetchAccountIdByTypeSymbol(symbol string) FetchAccountIdByTypeOptions {
    return func(opts *FetchAccountIdByTypeOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchAccountIdByTypeParams(params map[string]interface{}) FetchAccountIdByTypeOptions {
    return func(opts *FetchAccountIdByTypeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchSpotOrdersByStatesOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchSpotOrdersByStatesOptions func(opts *FetchSpotOrdersByStatesOptionsStruct)

func WithFetchSpotOrdersByStatesSymbol(symbol string) FetchSpotOrdersByStatesOptions {
    return func(opts *FetchSpotOrdersByStatesOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchSpotOrdersByStatesSince(since int64) FetchSpotOrdersByStatesOptions {
    return func(opts *FetchSpotOrdersByStatesOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchSpotOrdersByStatesLimit(limit int64) FetchSpotOrdersByStatesOptions {
    return func(opts *FetchSpotOrdersByStatesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchSpotOrdersByStatesParams(params map[string]interface{}) FetchSpotOrdersByStatesOptions {
    return func(opts *FetchSpotOrdersByStatesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchSpotOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchSpotOrdersOptions func(opts *FetchSpotOrdersOptionsStruct)

func WithFetchSpotOrdersSymbol(symbol string) FetchSpotOrdersOptions {
    return func(opts *FetchSpotOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchSpotOrdersSince(since int64) FetchSpotOrdersOptions {
    return func(opts *FetchSpotOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchSpotOrdersLimit(limit int64) FetchSpotOrdersOptions {
    return func(opts *FetchSpotOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchSpotOrdersParams(params map[string]interface{}) FetchSpotOrdersOptions {
    return func(opts *FetchSpotOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchClosedSpotOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchClosedSpotOrdersOptions func(opts *FetchClosedSpotOrdersOptionsStruct)

func WithFetchClosedSpotOrdersSymbol(symbol string) FetchClosedSpotOrdersOptions {
    return func(opts *FetchClosedSpotOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchClosedSpotOrdersSince(since int64) FetchClosedSpotOrdersOptions {
    return func(opts *FetchClosedSpotOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchClosedSpotOrdersLimit(limit int64) FetchClosedSpotOrdersOptions {
    return func(opts *FetchClosedSpotOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchClosedSpotOrdersParams(params map[string]interface{}) FetchClosedSpotOrdersOptions {
    return func(opts *FetchClosedSpotOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchContractOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchContractOrdersOptions func(opts *FetchContractOrdersOptionsStruct)

func WithFetchContractOrdersSymbol(symbol string) FetchContractOrdersOptions {
    return func(opts *FetchContractOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchContractOrdersSince(since int64) FetchContractOrdersOptions {
    return func(opts *FetchContractOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchContractOrdersLimit(limit int64) FetchContractOrdersOptions {
    return func(opts *FetchContractOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchContractOrdersParams(params map[string]interface{}) FetchContractOrdersOptions {
    return func(opts *FetchContractOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type FetchClosedContractOrdersOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchClosedContractOrdersOptions func(opts *FetchClosedContractOrdersOptionsStruct)

func WithFetchClosedContractOrdersSymbol(symbol string) FetchClosedContractOrdersOptions {
    return func(opts *FetchClosedContractOrdersOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchClosedContractOrdersSince(since int64) FetchClosedContractOrdersOptions {
    return func(opts *FetchClosedContractOrdersOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchClosedContractOrdersLimit(limit int64) FetchClosedContractOrdersOptions {
    return func(opts *FetchClosedContractOrdersOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchClosedContractOrdersParams(params map[string]interface{}) FetchClosedContractOrdersOptions {
    return func(opts *FetchClosedContractOrdersOptionsStruct) {
        opts.Params = &params
    }
}


type CreateTrailingPercentOrderOptionsStruct struct {
    Price *float64
    TrailingPercent *interface{}
    TrailingTriggerPrice *interface{}
    Params *map[string]interface{}
}

type CreateTrailingPercentOrderOptions func(opts *CreateTrailingPercentOrderOptionsStruct)

func WithCreateTrailingPercentOrderPrice(price float64) CreateTrailingPercentOrderOptions {
    return func(opts *CreateTrailingPercentOrderOptionsStruct) {
        opts.Price = &price
    }
}


func WithCreateTrailingPercentOrderTrailingPercent(trailingPercent interface{}) CreateTrailingPercentOrderOptions {
    return func(opts *CreateTrailingPercentOrderOptionsStruct) {
        opts.TrailingPercent = &trailingPercent
    }
}


func WithCreateTrailingPercentOrderTrailingTriggerPrice(trailingTriggerPrice interface{}) CreateTrailingPercentOrderOptions {
    return func(opts *CreateTrailingPercentOrderOptionsStruct) {
        opts.TrailingTriggerPrice = &trailingTriggerPrice
    }
}


func WithCreateTrailingPercentOrderParams(params map[string]interface{}) CreateTrailingPercentOrderOptions {
    return func(opts *CreateTrailingPercentOrderOptionsStruct) {
        opts.Params = &params
    }
}


type CreateSpotOrderRequestOptionsStruct struct {
    Price *float64
    Params *map[string]interface{}
}

type CreateSpotOrderRequestOptions func(opts *CreateSpotOrderRequestOptionsStruct)

func WithCreateSpotOrderRequestPrice(price float64) CreateSpotOrderRequestOptions {
    return func(opts *CreateSpotOrderRequestOptionsStruct) {
        opts.Price = &price
    }
}


func WithCreateSpotOrderRequestParams(params map[string]interface{}) CreateSpotOrderRequestOptions {
    return func(opts *CreateSpotOrderRequestOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersByStatesOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrdersByStatesOptions func(opts *FetchOrdersByStatesOptionsStruct)

func WithFetchOrdersByStatesSymbol(symbol string) FetchOrdersByStatesOptions {
    return func(opts *FetchOrdersByStatesOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersByStatesSince(since int64) FetchOrdersByStatesOptions {
    return func(opts *FetchOrdersByStatesOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrdersByStatesLimit(limit int64) FetchOrdersByStatesOptions {
    return func(opts *FetchOrdersByStatesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrdersByStatesParams(params map[string]interface{}) FetchOrdersByStatesOptions {
    return func(opts *FetchOrdersByStatesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenOrdersV1OptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOpenOrdersV1Options func(opts *FetchOpenOrdersV1OptionsStruct)

func WithFetchOpenOrdersV1Symbol(symbol string) FetchOpenOrdersV1Options {
    return func(opts *FetchOpenOrdersV1OptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOpenOrdersV1Since(since int64) FetchOpenOrdersV1Options {
    return func(opts *FetchOpenOrdersV1OptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOpenOrdersV1Limit(limit int64) FetchOpenOrdersV1Options {
    return func(opts *FetchOpenOrdersV1OptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOpenOrdersV1Params(params map[string]interface{}) FetchOpenOrdersV1Options {
    return func(opts *FetchOpenOrdersV1OptionsStruct) {
        opts.Params = &params
    }
}


type FetchOpenOrdersV2OptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOpenOrdersV2Options func(opts *FetchOpenOrdersV2OptionsStruct)

func WithFetchOpenOrdersV2Symbol(symbol string) FetchOpenOrdersV2Options {
    return func(opts *FetchOpenOrdersV2OptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOpenOrdersV2Since(since int64) FetchOpenOrdersV2Options {
    return func(opts *FetchOpenOrdersV2OptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOpenOrdersV2Limit(limit int64) FetchOpenOrdersV2Options {
    return func(opts *FetchOpenOrdersV2OptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOpenOrdersV2Params(params map[string]interface{}) FetchOpenOrdersV2Options {
    return func(opts *FetchOpenOrdersV2OptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersHelperOptionsStruct struct {
    Symbol *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchOrdersHelperOptions func(opts *FetchOrdersHelperOptionsStruct)

func WithFetchOrdersHelperSymbol(symbol string) FetchOrdersHelperOptions {
    return func(opts *FetchOrdersHelperOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersHelperSince(since int64) FetchOrdersHelperOptions {
    return func(opts *FetchOrdersHelperOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchOrdersHelperLimit(limit int64) FetchOrdersHelperOptions {
    return func(opts *FetchOrdersHelperOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchOrdersHelperParams(params map[string]interface{}) FetchOrdersHelperOptions {
    return func(opts *FetchOrdersHelperOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransactionsHelperOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchTransactionsHelperOptions func(opts *FetchTransactionsHelperOptionsStruct)

func WithFetchTransactionsHelperCode(code string) FetchTransactionsHelperOptions {
    return func(opts *FetchTransactionsHelperOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchTransactionsHelperSince(since int64) FetchTransactionsHelperOptions {
    return func(opts *FetchTransactionsHelperOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchTransactionsHelperLimit(limit int64) FetchTransactionsHelperOptions {
    return func(opts *FetchTransactionsHelperOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchTransactionsHelperParams(params map[string]interface{}) FetchTransactionsHelperOptions {
    return func(opts *FetchTransactionsHelperOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLedgerEntriesByIdsOptionsStruct struct {
    Code *string
    Params *map[string]interface{}
}

type FetchLedgerEntriesByIdsOptions func(opts *FetchLedgerEntriesByIdsOptionsStruct)

func WithFetchLedgerEntriesByIdsCode(code string) FetchLedgerEntriesByIdsOptions {
    return func(opts *FetchLedgerEntriesByIdsOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchLedgerEntriesByIdsParams(params map[string]interface{}) FetchLedgerEntriesByIdsOptions {
    return func(opts *FetchLedgerEntriesByIdsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrdersByIdsOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchOrdersByIdsOptions func(opts *FetchOrdersByIdsOptionsStruct)

func WithFetchOrdersByIdsSymbol(symbol string) FetchOrdersByIdsOptions {
    return func(opts *FetchOrdersByIdsOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrdersByIdsParams(params map[string]interface{}) FetchOrdersByIdsOptions {
    return func(opts *FetchOrdersByIdsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositMethodsOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchDepositMethodsOptions func(opts *FetchDepositMethodsOptionsStruct)

func WithFetchDepositMethodsParams(params map[string]interface{}) FetchDepositMethodsOptions {
    return func(opts *FetchDepositMethodsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchBorrowRateHistoriesOptionsStruct struct {
    Codes *interface{}
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchBorrowRateHistoriesOptions func(opts *FetchBorrowRateHistoriesOptionsStruct)

func WithFetchBorrowRateHistoriesCodes(codes interface{}) FetchBorrowRateHistoriesOptions {
    return func(opts *FetchBorrowRateHistoriesOptionsStruct) {
        opts.Codes = &codes
    }
}


func WithFetchBorrowRateHistoriesSince(since int64) FetchBorrowRateHistoriesOptions {
    return func(opts *FetchBorrowRateHistoriesOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchBorrowRateHistoriesLimit(limit int64) FetchBorrowRateHistoriesOptions {
    return func(opts *FetchBorrowRateHistoriesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchBorrowRateHistoriesParams(params map[string]interface{}) FetchBorrowRateHistoriesOptions {
    return func(opts *FetchBorrowRateHistoriesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPublicTradingFeeOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchPublicTradingFeeOptions func(opts *FetchPublicTradingFeeOptionsStruct)

func WithFetchPublicTradingFeeParams(params map[string]interface{}) FetchPublicTradingFeeOptions {
    return func(opts *FetchPublicTradingFeeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPrivateTradingFeeOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchPrivateTradingFeeOptions func(opts *FetchPrivateTradingFeeOptionsStruct)

func WithFetchPrivateTradingFeeParams(params map[string]interface{}) FetchPrivateTradingFeeOptions {
    return func(opts *FetchPrivateTradingFeeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransactionsOptionsStruct struct {
    Code *string
    Since *int64
    Limit *int64
    Params *map[string]interface{}
}

type FetchTransactionsOptions func(opts *FetchTransactionsOptionsStruct)

func WithFetchTransactionsCode(code string) FetchTransactionsOptions {
    return func(opts *FetchTransactionsOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchTransactionsSince(since int64) FetchTransactionsOptions {
    return func(opts *FetchTransactionsOptionsStruct) {
        opts.Since = &since
    }
}


func WithFetchTransactionsLimit(limit int64) FetchTransactionsOptions {
    return func(opts *FetchTransactionsOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchTransactionsParams(params map[string]interface{}) FetchTransactionsOptions {
    return func(opts *FetchTransactionsOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrderSupplementOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchOrderSupplementOptions func(opts *FetchOrderSupplementOptionsStruct)

func WithFetchOrderSupplementSymbol(symbol string) FetchOrderSupplementOptions {
    return func(opts *FetchOrderSupplementOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrderSupplementParams(params map[string]interface{}) FetchOrderSupplementOptions {
    return func(opts *FetchOrderSupplementOptionsStruct) {
        opts.Params = &params
    }
}


type FetchOrderDefaultOptionsStruct struct {
    Symbol *string
    Params *map[string]interface{}
}

type FetchOrderDefaultOptions func(opts *FetchOrderDefaultOptionsStruct)

func WithFetchOrderDefaultSymbol(symbol string) FetchOrderDefaultOptions {
    return func(opts *FetchOrderDefaultOptionsStruct) {
        opts.Symbol = &symbol
    }
}


func WithFetchOrderDefaultParams(params map[string]interface{}) FetchOrderDefaultOptions {
    return func(opts *FetchOrderDefaultOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositAddressDefaultOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchDepositAddressDefaultOptions func(opts *FetchDepositAddressDefaultOptionsStruct)

func WithFetchDepositAddressDefaultParams(params map[string]interface{}) FetchDepositAddressDefaultOptions {
    return func(opts *FetchDepositAddressDefaultOptionsStruct) {
        opts.Params = &params
    }
}


type FetchDepositAddressSupplementOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchDepositAddressSupplementOptions func(opts *FetchDepositAddressSupplementOptionsStruct)

func WithFetchDepositAddressSupplementParams(params map[string]interface{}) FetchDepositAddressSupplementOptions {
    return func(opts *FetchDepositAddressSupplementOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPrivateDepositWithdrawFeesOptionsStruct struct {
    Codes *interface{}
    Params *map[string]interface{}
}

type FetchPrivateDepositWithdrawFeesOptions func(opts *FetchPrivateDepositWithdrawFeesOptionsStruct)

func WithFetchPrivateDepositWithdrawFeesCodes(codes interface{}) FetchPrivateDepositWithdrawFeesOptions {
    return func(opts *FetchPrivateDepositWithdrawFeesOptionsStruct) {
        opts.Codes = &codes
    }
}


func WithFetchPrivateDepositWithdrawFeesParams(params map[string]interface{}) FetchPrivateDepositWithdrawFeesOptions {
    return func(opts *FetchPrivateDepositWithdrawFeesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchPublicDepositWithdrawFeesOptionsStruct struct {
    Codes *interface{}
    Params *map[string]interface{}
}

type FetchPublicDepositWithdrawFeesOptions func(opts *FetchPublicDepositWithdrawFeesOptionsStruct)

func WithFetchPublicDepositWithdrawFeesCodes(codes interface{}) FetchPublicDepositWithdrawFeesOptions {
    return func(opts *FetchPublicDepositWithdrawFeesOptionsStruct) {
        opts.Codes = &codes
    }
}


func WithFetchPublicDepositWithdrawFeesParams(params map[string]interface{}) FetchPublicDepositWithdrawFeesOptions {
    return func(opts *FetchPublicDepositWithdrawFeesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchLedgerByEntriesOptionsStruct struct {
    Code *string
    Entry *interface{}
    Limit *interface{}
    Params *map[string]interface{}
}

type FetchLedgerByEntriesOptions func(opts *FetchLedgerByEntriesOptionsStruct)

func WithFetchLedgerByEntriesCode(code string) FetchLedgerByEntriesOptions {
    return func(opts *FetchLedgerByEntriesOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchLedgerByEntriesEntry(entry interface{}) FetchLedgerByEntriesOptions {
    return func(opts *FetchLedgerByEntriesOptionsStruct) {
        opts.Entry = &entry
    }
}


func WithFetchLedgerByEntriesLimit(limit interface{}) FetchLedgerByEntriesOptions {
    return func(opts *FetchLedgerByEntriesOptionsStruct) {
        opts.Limit = &limit
    }
}


func WithFetchLedgerByEntriesParams(params map[string]interface{}) FetchLedgerByEntriesOptions {
    return func(opts *FetchLedgerByEntriesOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTransferOptionsStruct struct {
    Code *string
    Params *map[string]interface{}
}

type FetchTransferOptions func(opts *FetchTransferOptionsStruct)

func WithFetchTransferCode(code string) FetchTransferOptions {
    return func(opts *FetchTransferOptionsStruct) {
        opts.Code = &code
    }
}


func WithFetchTransferParams(params map[string]interface{}) FetchTransferOptions {
    return func(opts *FetchTransferOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarketsByTypeOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchMarketsByTypeOptions func(opts *FetchMarketsByTypeOptionsStruct)

func WithFetchMarketsByTypeParams(params map[string]interface{}) FetchMarketsByTypeOptions {
    return func(opts *FetchMarketsByTypeOptionsStruct) {
        opts.Params = &params
    }
}


type FetchCurrencyOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchCurrencyOptions func(opts *FetchCurrencyOptionsStruct)

func WithFetchCurrencyParams(params map[string]interface{}) FetchCurrencyOptions {
    return func(opts *FetchCurrencyOptionsStruct) {
        opts.Params = &params
    }
}


type FetchCurrencyByIdOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchCurrencyByIdOptions func(opts *FetchCurrencyByIdOptionsStruct)

func WithFetchCurrencyByIdParams(params map[string]interface{}) FetchCurrencyByIdOptions {
    return func(opts *FetchCurrencyByIdOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarketOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchMarketOptions func(opts *FetchMarketOptionsStruct)

func WithFetchMarketParams(params map[string]interface{}) FetchMarketOptions {
    return func(opts *FetchMarketOptionsStruct) {
        opts.Params = &params
    }
}


type FetchMarketByIdOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchMarketByIdOptions func(opts *FetchMarketByIdOptionsStruct)

func WithFetchMarketByIdParams(params map[string]interface{}) FetchMarketByIdOptions {
    return func(opts *FetchMarketByIdOptionsStruct) {
        opts.Params = &params
    }
}


type CreateTrailingAmountOrderOptionsStruct struct {
    Price *float64
    TrailingAmount *interface{}
    TrailingTriggerPrice *interface{}
    Params *map[string]interface{}
}

type CreateTrailingAmountOrderOptions func(opts *CreateTrailingAmountOrderOptionsStruct)

func WithCreateTrailingAmountOrderPrice(price float64) CreateTrailingAmountOrderOptions {
    return func(opts *CreateTrailingAmountOrderOptionsStruct) {
        opts.Price = &price
    }
}


func WithCreateTrailingAmountOrderTrailingAmount(trailingAmount interface{}) CreateTrailingAmountOrderOptions {
    return func(opts *CreateTrailingAmountOrderOptionsStruct) {
        opts.TrailingAmount = &trailingAmount
    }
}


func WithCreateTrailingAmountOrderTrailingTriggerPrice(trailingTriggerPrice interface{}) CreateTrailingAmountOrderOptions {
    return func(opts *CreateTrailingAmountOrderOptionsStruct) {
        opts.TrailingTriggerPrice = &trailingTriggerPrice
    }
}


func WithCreateTrailingAmountOrderParams(params map[string]interface{}) CreateTrailingAmountOrderOptions {
    return func(opts *CreateTrailingAmountOrderOptionsStruct) {
        opts.Params = &params
    }
}


type FetchTickersHelperOptionsStruct struct {
    Params *map[string]interface{}
}

type FetchTickersHelperOptions func(opts *FetchTickersHelperOptionsStruct)

func WithFetchTickersHelperParams(params map[string]interface{}) FetchTickersHelperOptions {
    return func(opts *FetchTickersHelperOptionsStruct) {
        opts.Params = &params
    }
}