coinank.go

// Auto-generated by claw402 codegen — DO NOT EDIT
// Provider: CoinAnk (coinank)

package claw402

import (
	"context"
	"encoding/json"
)

// CoinankKline provides methods for Coinank kline endpoints.
type CoinankKline struct {
	client *Client
}

// CoinankKlineListsParams are the query parameters for Lists.
type CoinankKlineListsParams struct {
	Symbol string `json:"symbol,omitempty"`
	Exchange string `json:"exchange,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	Interval string `json:"interval,omitempty"`
	ProductType string `json:"productType,omitempty"`
}

// Candlestick data (SWAP/SPOT, multi-exchange) — $0.001/call
func (r *CoinankKline) Lists(ctx context.Context, params *CoinankKlineListsParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	return r.client.get(ctx, "/api/v1/coinank/kline/lists", q)
}

// CoinankEtf provides methods for Coinank etf endpoints.
type CoinankEtf struct {
	client *Client
}

// US Bitcoin ETF list (IBIT, FBTC, etc.) — $0.001/call
func (r *CoinankEtf) UsBtc(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/etf/us-btc", nil)
}

// US Ethereum ETF list — $0.001/call
func (r *CoinankEtf) UsEth(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/etf/us-eth", nil)
}

// US BTC ETF historical net inflow data — $0.001/call
func (r *CoinankEtf) UsBtcInflow(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/etf/us-btc-inflow", nil)
}

// US ETH ETF historical net inflow data — $0.001/call
func (r *CoinankEtf) UsEthInflow(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/etf/us-eth-inflow", nil)
}

// Hong Kong ETF historical net inflow data — $0.001/call
func (r *CoinankEtf) HkInflow(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/etf/hk-inflow", nil)
}

// CoinankHyper provides methods for Coinank hyper endpoints.
type CoinankHyper struct {
	client *Client
}

// CoinankHyperTopPositionParams are the query parameters for TopPosition.
type CoinankHyperTopPositionParams struct {
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
	Page string `json:"page,omitempty"`
	Size string `json:"size,omitempty"`
}

// HyperLiquid whale position rankings — $0.001/call
func (r *CoinankHyper) TopPosition(ctx context.Context, params *CoinankHyperTopPositionParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	if params != nil && params.Page != "" {
		q["page"] = params.Page
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/hyper/top-position", q)
}

// HyperLiquid whale latest trade actions — $0.001/call
func (r *CoinankHyper) TopAction(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/hyper/top-action", nil)
}

// CoinankTrades provides methods for Coinank trades endpoints.
type CoinankTrades struct {
	client *Client
}

// CoinankTradesLargeParams are the query parameters for Large.
type CoinankTradesLargeParams struct {
	Symbol string `json:"symbol,omitempty"`
	ProductType string `json:"productType,omitempty"`
	Amount string `json:"amount,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Large market order list (whale trade monitor) — $0.001/call
func (r *CoinankTrades) Large(ctx context.Context, params *CoinankTradesLargeParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Amount != "" {
		q["amount"] = params.Amount
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/trades/large", q)
}

// CoinankBigOrder provides methods for Coinank bigOrder endpoints.
type CoinankBigOrder struct {
	client *Client
}

// CoinankBigOrderListParams are the query parameters for List.
type CoinankBigOrderListParams struct {
	Symbol string `json:"symbol,omitempty"`
	ExchangeType string `json:"exchangeType,omitempty"`
	Size string `json:"size,omitempty"`
	Amount string `json:"amount,omitempty"`
	Side string `json:"side,omitempty"`
	Exchange string `json:"exchange,omitempty"`
	IsHistory string `json:"isHistory,omitempty"`
	StartTime string `json:"startTime,omitempty"`
}

// Large limit order list — $0.001/call
func (r *CoinankBigOrder) List(ctx context.Context, params *CoinankBigOrderListParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.ExchangeType != "" {
		q["exchangeType"] = params.ExchangeType
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Amount != "" {
		q["amount"] = params.Amount
	}
	if params != nil && params.Side != "" {
		q["side"] = params.Side
	}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.IsHistory != "" {
		q["isHistory"] = params.IsHistory
	}
	if params != nil && params.StartTime != "" {
		q["startTime"] = params.StartTime
	}
	return r.client.get(ctx, "/api/v1/coinank/big-order/list", q)
}

// CoinankPrice provides methods for Coinank price endpoints.
type CoinankPrice struct {
	client *Client
}

// CoinankPriceLastParams are the query parameters for Last.
type CoinankPriceLastParams struct {
	Symbol string `json:"symbol,omitempty"`
	Exchange string `json:"exchange,omitempty"`
	ProductType string `json:"productType,omitempty"`
}

// Trading pair latest real-time price — $0.001/call
func (r *CoinankPrice) Last(ctx context.Context, params *CoinankPriceLastParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	return r.client.get(ctx, "/api/v1/coinank/price/last", q)
}

// CoinankCoin provides methods for Coinank coin endpoints.
type CoinankCoin struct {
	client *Client
}

// CoinankCoinMarketCapParams are the query parameters for MarketCap.
type CoinankCoinMarketCapParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
}

// Coin market cap information — $0.001/call
func (r *CoinankCoin) MarketCap(ctx context.Context, params *CoinankCoinMarketCapParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	return r.client.get(ctx, "/api/v1/coinank/coin/market-cap", q)
}

// CoinankCoinListParams are the query parameters for List.
type CoinankCoinListParams struct {
	ProductType string `json:"productType,omitempty"`
}

// Supported coins list — $0.001/call
func (r *CoinankCoin) List(ctx context.Context, params *CoinankCoinListParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	return r.client.get(ctx, "/api/v1/coinank/coin/list", q)
}

// CoinankCoinSymbolsParams are the query parameters for Symbols.
type CoinankCoinSymbolsParams struct {
	Exchange string `json:"exchange,omitempty"`
	ProductType string `json:"productType,omitempty"`
}

// Supported trading pairs list (by exchange) — $0.001/call
func (r *CoinankCoin) Symbols(ctx context.Context, params *CoinankCoinSymbolsParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	return r.client.get(ctx, "/api/v1/coinank/coin/symbols", q)
}

// CoinankLongshort provides methods for Coinank longshort endpoints.
type CoinankLongshort struct {
	client *Client
}

// CoinankLongshortBuySellParams are the query parameters for BuySell.
type CoinankLongshortBuySellParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Global long/short buy-sell ratio history — $0.001/call
func (r *CoinankLongshort) BuySell(ctx context.Context, params *CoinankLongshortBuySellParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/longshort/buy-sell", q)
}

// CoinankLongshortRealtimeParams are the query parameters for Realtime.
type CoinankLongshortRealtimeParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
}

// Real-time long/short ratio by exchange — $0.001/call
func (r *CoinankLongshort) Realtime(ctx context.Context, params *CoinankLongshortRealtimeParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	return r.client.get(ctx, "/api/v1/coinank/longshort/realtime", q)
}

// CoinankLongshortPersonParams are the query parameters for Person.
type CoinankLongshortPersonParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Long/short account count ratio history (Binance/OKX/Bybit) — $0.001/call
func (r *CoinankLongshort) Person(ctx context.Context, params *CoinankLongshortPersonParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/longshort/person", q)
}

// CoinankLongshortPositionParams are the query parameters for Position.
type CoinankLongshortPositionParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Whale long/short position ratio (by position size) — $0.001/call
func (r *CoinankLongshort) Position(ctx context.Context, params *CoinankLongshortPositionParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/longshort/position", q)
}

// CoinankLongshortAccountParams are the query parameters for Account.
type CoinankLongshortAccountParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Whale long/short ratio by account count (VIP1) — $0.001/call
func (r *CoinankLongshort) Account(ctx context.Context, params *CoinankLongshortAccountParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/longshort/account", q)
}

// CoinankLongshortKlineParams are the query parameters for Kline.
type CoinankLongshortKlineParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	Type string `json:"type,omitempty"`
}

// Long/short ratio candlestick (VIP1; type: longShortPerson/Position/Account) — $0.001/call
func (r *CoinankLongshort) Kline(ctx context.Context, params *CoinankLongshortKlineParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	return r.client.get(ctx, "/api/v1/coinank/longshort/kline", q)
}

// CoinankMarketOrder provides methods for Coinank marketOrder endpoints.
type CoinankMarketOrder struct {
	client *Client
}

// CoinankMarketOrderCvdParams are the query parameters for Cvd.
type CoinankMarketOrderCvdParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
}

// CVD cumulative volume delta — single pair (VIP3) — $0.001/call
func (r *CoinankMarketOrder) Cvd(ctx context.Context, params *CoinankMarketOrderCvdParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	return r.client.get(ctx, "/api/v1/coinank/market-order/cvd", q)
}

// CoinankMarketOrderBuySellCountParams are the query parameters for BuySellCount.
type CoinankMarketOrderBuySellCountParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
}

// Market buy/sell order count — single pair (VIP3) — $0.001/call
func (r *CoinankMarketOrder) BuySellCount(ctx context.Context, params *CoinankMarketOrderBuySellCountParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	return r.client.get(ctx, "/api/v1/coinank/market-order/buy-sell-count", q)
}

// CoinankMarketOrderBuySellValueParams are the query parameters for BuySellValue.
type CoinankMarketOrderBuySellValueParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
}

// Market buy/sell value in USD — single pair (VIP3) — $0.001/call
func (r *CoinankMarketOrder) BuySellValue(ctx context.Context, params *CoinankMarketOrderBuySellValueParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	return r.client.get(ctx, "/api/v1/coinank/market-order/buy-sell-value", q)
}

// CoinankMarketOrderBuySellVolumeParams are the query parameters for BuySellVolume.
type CoinankMarketOrderBuySellVolumeParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
}

// Market buy/sell volume in coins — single pair (VIP3) — $0.001/call
func (r *CoinankMarketOrder) BuySellVolume(ctx context.Context, params *CoinankMarketOrderBuySellVolumeParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	return r.client.get(ctx, "/api/v1/coinank/market-order/buy-sell-volume", q)
}

// CoinankMarketOrderAggCvdParams are the query parameters for AggCvd.
type CoinankMarketOrderAggCvdParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
	Exchanges string `json:"exchanges,omitempty"`
}

// Aggregated CVD across exchanges (VIP3) — $0.001/call
func (r *CoinankMarketOrder) AggCvd(ctx context.Context, params *CoinankMarketOrderAggCvdParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Exchanges != "" {
		q["exchanges"] = params.Exchanges
	}
	return r.client.get(ctx, "/api/v1/coinank/market-order/agg-cvd", q)
}

// CoinankMarketOrderAggBuySellCountParams are the query parameters for AggBuySellCount.
type CoinankMarketOrderAggBuySellCountParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
	Exchanges string `json:"exchanges,omitempty"`
}

// Aggregated buy/sell count across exchanges (VIP3) — $0.001/call
func (r *CoinankMarketOrder) AggBuySellCount(ctx context.Context, params *CoinankMarketOrderAggBuySellCountParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Exchanges != "" {
		q["exchanges"] = params.Exchanges
	}
	return r.client.get(ctx, "/api/v1/coinank/market-order/agg-buy-sell-count", q)
}

// CoinankMarketOrderAggBuySellValueParams are the query parameters for AggBuySellValue.
type CoinankMarketOrderAggBuySellValueParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
	Exchanges string `json:"exchanges,omitempty"`
}

// Aggregated buy/sell value across exchanges (VIP3) — $0.001/call
func (r *CoinankMarketOrder) AggBuySellValue(ctx context.Context, params *CoinankMarketOrderAggBuySellValueParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Exchanges != "" {
		q["exchanges"] = params.Exchanges
	}
	return r.client.get(ctx, "/api/v1/coinank/market-order/agg-buy-sell-value", q)
}

// CoinankMarketOrderAggBuySellVolumeParams are the query parameters for AggBuySellVolume.
type CoinankMarketOrderAggBuySellVolumeParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
	Exchanges string `json:"exchanges,omitempty"`
}

// Aggregated buy/sell volume across exchanges (VIP3) — $0.001/call
func (r *CoinankMarketOrder) AggBuySellVolume(ctx context.Context, params *CoinankMarketOrderAggBuySellVolumeParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Exchanges != "" {
		q["exchanges"] = params.Exchanges
	}
	return r.client.get(ctx, "/api/v1/coinank/market-order/agg-buy-sell-volume", q)
}

// CoinankNews provides methods for Coinank news endpoints.
type CoinankNews struct {
	client *Client
}

// CoinankNewsListParams are the query parameters for List.
type CoinankNewsListParams struct {
	Type string `json:"type,omitempty"`
	Lang string `json:"lang,omitempty"`
	Page string `json:"page,omitempty"`
	PageSize string `json:"pageSize,omitempty"`
	IsPopular string `json:"isPopular,omitempty"`
	Search string `json:"search,omitempty"`
}

// News/flash list (type:1=flash,2=news; lang:zh/en) — $0.001/call
func (r *CoinankNews) List(ctx context.Context, params *CoinankNewsListParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	if params != nil && params.Lang != "" {
		q["lang"] = params.Lang
	}
	if params != nil && params.Page != "" {
		q["page"] = params.Page
	}
	if params != nil && params.PageSize != "" {
		q["pageSize"] = params.PageSize
	}
	if params != nil && params.IsPopular != "" {
		q["isPopular"] = params.IsPopular
	}
	if params != nil && params.Search != "" {
		q["search"] = params.Search
	}
	return r.client.get(ctx, "/api/v1/coinank/news/list", q)
}

// CoinankNewsDetailParams are the query parameters for Detail.
type CoinankNewsDetailParams struct {
	Id string `json:"id,omitempty"`
}

// News/flash detail (id from news/list) — $0.001/call
func (r *CoinankNews) Detail(ctx context.Context, params *CoinankNewsDetailParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Id != "" {
		q["id"] = params.Id
	}
	return r.client.get(ctx, "/api/v1/coinank/news/detail", q)
}

// CoinankIndicator provides methods for Coinank indicator endpoints.
type CoinankIndicator struct {
	client *Client
}

// BTC 2-year MA multiplier indicator — $0.001/call
func (r *CoinankIndicator) BtcMultiplier(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/indicator/btc-multiplier", nil)
}

// Crypto fear & greed index — $0.001/call
func (r *CoinankIndicator) FearGreed(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/indicator/fear-greed", nil)
}

// AHR999 Bitcoin accumulation indicator — $0.001/call
func (r *CoinankIndicator) Ahr999(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/indicator/ahr999", nil)
}

// Puell Multiple indicator — $0.001/call
func (r *CoinankIndicator) PuellMultiple(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/indicator/puell-multiple", nil)
}

// Pi Cycle Top indicator — $0.001/call
func (r *CoinankIndicator) BtcPi(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/indicator/btc-pi", nil)
}

// 200-week moving average heatmap — $0.001/call
func (r *CoinankIndicator) MaHeatmap(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/indicator/ma-heatmap", nil)
}

// Altcoin Season Index — $0.001/call
func (r *CoinankIndicator) AltcoinSeason(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/indicator/altcoin-season", nil)
}

// CoinankIndicatorMarketCapRankParams are the query parameters for MarketCapRank.
type CoinankIndicatorMarketCapRankParams struct {
	Symbol string `json:"symbol,omitempty"`
}

// Coin market cap dominance rankings — $0.001/call
func (r *CoinankIndicator) MarketCapRank(ctx context.Context, params *CoinankIndicatorMarketCapRankParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	return r.client.get(ctx, "/api/v1/coinank/indicator/market-cap-rank", q)
}

// CoinankIndicatorGrayscaleParams are the query parameters for Grayscale.
type CoinankIndicatorGrayscaleParams struct {
	Symbol string `json:"symbol,omitempty"`
}

// Grayscale holdings data (GBTC/ETHE, etc.) — $0.001/call
func (r *CoinankIndicator) Grayscale(ctx context.Context, params *CoinankIndicatorGrayscaleParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	return r.client.get(ctx, "/api/v1/coinank/indicator/grayscale", q)
}

// CoinankIndicatorChartsParams are the query parameters for Charts.
type CoinankIndicatorChartsParams struct {
	Type string `json:"type,omitempty"`
}

// Composite indicator charts (type=bitcoin-rainbow-v2) — $0.001/call
func (r *CoinankIndicator) Charts(ctx context.Context, params *CoinankIndicatorChartsParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	return r.client.get(ctx, "/api/v1/coinank/indicator/charts", q)
}

// CoinankOi provides methods for Coinank oi endpoints.
type CoinankOi struct {
	client *Client
}

// CoinankOiAllParams are the query parameters for All.
type CoinankOiAllParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
}

// Real-time open interest list by exchange — $0.001/call
func (r *CoinankOi) All(ctx context.Context, params *CoinankOiAllParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	return r.client.get(ctx, "/api/v1/coinank/oi/all", q)
}

// CoinankOiAggChartParams are the query parameters for AggChart.
type CoinankOiAggChartParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Exchange string `json:"exchange,omitempty"`
	Interval string `json:"interval,omitempty"`
	Size string `json:"size,omitempty"`
	Type string `json:"type,omitempty"`
	EndTime string `json:"endTime,omitempty"`
}

// Coin aggregated OI history (exchange=empty for all) — $0.001/call
func (r *CoinankOi) AggChart(ctx context.Context, params *CoinankOiAggChartParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	return r.client.get(ctx, "/api/v1/coinank/oi/agg-chart", q)
}

// CoinankOiSymbolChartParams are the query parameters for SymbolChart.
type CoinankOiSymbolChartParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	Type string `json:"type,omitempty"`
}

// Trading pair open interest history — $0.001/call
func (r *CoinankOi) SymbolChart(ctx context.Context, params *CoinankOiSymbolChartParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	return r.client.get(ctx, "/api/v1/coinank/oi/symbol-chart", q)
}

// CoinankOiKlineParams are the query parameters for Kline.
type CoinankOiKlineParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Trading pair open interest candlestick — $0.001/call
func (r *CoinankOi) Kline(ctx context.Context, params *CoinankOiKlineParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/oi/kline", q)
}

// CoinankOiAggKlineParams are the query parameters for AggKline.
type CoinankOiAggKlineParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Aggregated open interest candlestick — $0.001/call
func (r *CoinankOi) AggKline(ctx context.Context, params *CoinankOiAggKlineParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/oi/agg-kline", q)
}

// CoinankOiByExchangeParams are the query parameters for ByExchange.
type CoinankOiByExchangeParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
}

// Real-time open interest breakdown by exchange — $0.001/call
func (r *CoinankOi) ByExchange(ctx context.Context, params *CoinankOiByExchangeParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	return r.client.get(ctx, "/api/v1/coinank/oi/by-exchange", q)
}

// CoinankOiVsMarketCapHistParams are the query parameters for VsMarketCapHist.
type CoinankOiVsMarketCapHistParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	Interval string `json:"interval,omitempty"`
}

// Historical open interest to market cap ratio — $0.001/call
func (r *CoinankOi) VsMarketCapHist(ctx context.Context, params *CoinankOiVsMarketCapHistParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	return r.client.get(ctx, "/api/v1/coinank/oi/vs-market-cap-hist", q)
}

// CoinankRank provides methods for Coinank rank endpoints.
type CoinankRank struct {
	client *Client
}

// CoinankRankScreenerParams are the query parameters for Screener.
type CoinankRankScreenerParams struct {
	Interval string `json:"interval,omitempty"`
}

// Visual screener (multi-dimensional rankings) — $0.001/call
func (r *CoinankRank) Screener(ctx context.Context, params *CoinankRankScreenerParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	return r.client.get(ctx, "/api/v1/coinank/rank/screener", q)
}

// CoinankRankOiVsMarketCapParams are the query parameters for OiVsMarketCap.
type CoinankRankOiVsMarketCapParams struct {
	Page string `json:"page,omitempty"`
	Size string `json:"size,omitempty"`
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
}

// Open interest vs market cap rankings (VIP2) — $0.001/call
func (r *CoinankRank) OiVsMarketCap(ctx context.Context, params *CoinankRankOiVsMarketCapParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Page != "" {
		q["page"] = params.Page
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	return r.client.get(ctx, "/api/v1/coinank/rank/oi-vs-market-cap", q)
}

// CoinankRankLongShortParams are the query parameters for LongShort.
type CoinankRankLongShortParams struct {
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
	Size string `json:"size,omitempty"`
	Page string `json:"page,omitempty"`
}

// Long/short account count ratio rankings — $0.001/call
func (r *CoinankRank) LongShort(ctx context.Context, params *CoinankRankLongShortParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Page != "" {
		q["page"] = params.Page
	}
	return r.client.get(ctx, "/api/v1/coinank/rank/long-short", q)
}

// CoinankRankOiParams are the query parameters for Oi.
type CoinankRankOiParams struct {
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
	Size string `json:"size,omitempty"`
	Page string `json:"page,omitempty"`
}

// Open interest amount rankings — $0.001/call
func (r *CoinankRank) Oi(ctx context.Context, params *CoinankRankOiParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Page != "" {
		q["page"] = params.Page
	}
	return r.client.get(ctx, "/api/v1/coinank/rank/oi", q)
}

// CoinankRankTradeCountParams are the query parameters for TradeCount.
type CoinankRankTradeCountParams struct {
	ProductType string `json:"productType,omitempty"`
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
}

// Trade count rankings (VIP2; sortBy: h1Count/h4Count/d1Count) — $0.001/call
func (r *CoinankRank) TradeCount(ctx context.Context, params *CoinankRankTradeCountParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	return r.client.get(ctx, "/api/v1/coinank/rank/trade-count", q)
}

// CoinankRankLiquidationParams are the query parameters for Liquidation.
type CoinankRankLiquidationParams struct {
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
	Page string `json:"page,omitempty"`
	Size string `json:"size,omitempty"`
}

// Liquidation amount rankings — $0.001/call
func (r *CoinankRank) Liquidation(ctx context.Context, params *CoinankRankLiquidationParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	if params != nil && params.Page != "" {
		q["page"] = params.Page
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/rank/liquidation", q)
}

// CoinankRankPriceParams are the query parameters for Price.
type CoinankRankPriceParams struct {
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
}

// Price change rankings (sortBy: priceChangeH24/priceChangeH1) — $0.001/call
func (r *CoinankRank) Price(ctx context.Context, params *CoinankRankPriceParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	return r.client.get(ctx, "/api/v1/coinank/rank/price", q)
}

// CoinankRankVolumeParams are the query parameters for Volume.
type CoinankRankVolumeParams struct {
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
}

// Volume change rankings (sortBy: h24Volume/h1Volume) — $0.001/call
func (r *CoinankRank) Volume(ctx context.Context, params *CoinankRankVolumeParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	return r.client.get(ctx, "/api/v1/coinank/rank/volume", q)
}

// CoinankLiquidation provides methods for Coinank liquidation endpoints.
type CoinankLiquidation struct {
	client *Client
}

// CoinankLiquidationIntervalsParams are the query parameters for Intervals.
type CoinankLiquidationIntervalsParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
}

// Liquidation statistics across time periods — $0.001/call
func (r *CoinankLiquidation) Intervals(ctx context.Context, params *CoinankLiquidationIntervalsParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	return r.client.get(ctx, "/api/v1/coinank/liquidation/intervals", q)
}

// CoinankLiquidationAggHistoryParams are the query parameters for AggHistory.
type CoinankLiquidationAggHistoryParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Aggregated liquidation history — $0.001/call
func (r *CoinankLiquidation) AggHistory(ctx context.Context, params *CoinankLiquidationAggHistoryParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/liquidation/agg-history", q)
}

// CoinankLiquidationHistoryParams are the query parameters for History.
type CoinankLiquidationHistoryParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Trading pair liquidation history — $0.001/call
func (r *CoinankLiquidation) History(ctx context.Context, params *CoinankLiquidationHistoryParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/liquidation/history", q)
}

// CoinankLiquidationOrdersParams are the query parameters for Orders.
type CoinankLiquidationOrdersParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Exchange string `json:"exchange,omitempty"`
	Side string `json:"side,omitempty"`
	Amount string `json:"amount,omitempty"`
	EndTime string `json:"endTime,omitempty"`
}

// Liquidation order list — $0.001/call
func (r *CoinankLiquidation) Orders(ctx context.Context, params *CoinankLiquidationOrdersParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Side != "" {
		q["side"] = params.Side
	}
	if params != nil && params.Amount != "" {
		q["amount"] = params.Amount
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	return r.client.get(ctx, "/api/v1/coinank/liquidation/orders", q)
}

// CoinankLiquidationLiqMapParams are the query parameters for LiqMap.
type CoinankLiquidationLiqMapParams struct {
	Symbol string `json:"symbol,omitempty"`
	Exchange string `json:"exchange,omitempty"`
	Interval string `json:"interval,omitempty"`
}

// Liquidation map (price level distribution) — $0.001/call
func (r *CoinankLiquidation) LiqMap(ctx context.Context, params *CoinankLiquidationLiqMapParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	return r.client.get(ctx, "/api/v1/coinank/liquidation/liq-map", q)
}

// CoinankLiquidationAggLiqMapParams are the query parameters for AggLiqMap.
type CoinankLiquidationAggLiqMapParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
}

// Aggregated liquidation map (VIP4) — $0.001/call
func (r *CoinankLiquidation) AggLiqMap(ctx context.Context, params *CoinankLiquidationAggLiqMapParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	return r.client.get(ctx, "/api/v1/coinank/liquidation/agg-liq-map", q)
}

// CoinankLiquidationHeatMapParams are the query parameters for HeatMap.
type CoinankLiquidationHeatMapParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
}

// Liquidation heatmap — $0.001/call
func (r *CoinankLiquidation) HeatMap(ctx context.Context, params *CoinankLiquidationHeatMapParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	return r.client.get(ctx, "/api/v1/coinank/liquidation/heat-map", q)
}

// Supported symbols for liquidation heatmap — $0.001/call
func (r *CoinankLiquidation) HeatMapSymbols(ctx context.Context) (json.RawMessage, error) {
	return r.client.get(ctx, "/api/v1/coinank/liquidation/heat-map-symbols", nil)
}

// CoinankOrderbook provides methods for Coinank orderbook endpoints.
type CoinankOrderbook struct {
	client *Client
}

// CoinankOrderbookBySymbolParams are the query parameters for BySymbol.
type CoinankOrderbookBySymbolParams struct {
	Symbol string `json:"symbol,omitempty"`
	Exchange string `json:"exchange,omitempty"`
	Rate string `json:"rate,omitempty"`
	ProductType string `json:"productType,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Order book depth history by trading pair (VIP3) — $0.001/call
func (r *CoinankOrderbook) BySymbol(ctx context.Context, params *CoinankOrderbookBySymbolParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Rate != "" {
		q["rate"] = params.Rate
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/orderbook/by-symbol", q)
}

// CoinankOrderbookByExchangeParams are the query parameters for ByExchange.
type CoinankOrderbookByExchangeParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	ProductType string `json:"productType,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	Exchanges string `json:"exchanges,omitempty"`
	Type string `json:"type,omitempty"`
}

// Order book depth history by exchange (VIP3) — $0.001/call
func (r *CoinankOrderbook) ByExchange(ctx context.Context, params *CoinankOrderbookByExchangeParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Exchanges != "" {
		q["exchanges"] = params.Exchanges
	}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	return r.client.get(ctx, "/api/v1/coinank/orderbook/by-exchange", q)
}

// CoinankOrderbookHeatmapParams are the query parameters for Heatmap.
type CoinankOrderbookHeatmapParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Order book liquidity heatmap (VIP4) — $0.001/call
func (r *CoinankOrderbook) Heatmap(ctx context.Context, params *CoinankOrderbookHeatmapParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/orderbook/heatmap", q)
}

// CoinankFund provides methods for Coinank fund endpoints.
type CoinankFund struct {
	client *Client
}

// CoinankFundRealtimeParams are the query parameters for Realtime.
type CoinankFundRealtimeParams struct {
	ProductType string `json:"productType,omitempty"`
	Page string `json:"page,omitempty"`
	Size string `json:"size,omitempty"`
	SortBy string `json:"sortBy,omitempty"`
	SortType string `json:"sortType,omitempty"`
	BaseCoin string `json:"baseCoin,omitempty"`
}

// Real-time fund flow rankings (sortBy: h1net/h4net/h8net/h24net) — $0.001/call
func (r *CoinankFund) Realtime(ctx context.Context, params *CoinankFundRealtimeParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Page != "" {
		q["page"] = params.Page
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.SortBy != "" {
		q["sortBy"] = params.SortBy
	}
	if params != nil && params.SortType != "" {
		q["sortType"] = params.SortType
	}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	return r.client.get(ctx, "/api/v1/coinank/fund/realtime", q)
}

// CoinankFundHistoryParams are the query parameters for History.
type CoinankFundHistoryParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	ProductType string `json:"productType,omitempty"`
	Size string `json:"size,omitempty"`
	Interval string `json:"interval,omitempty"`
}

// Historical fund flow data — $0.001/call
func (r *CoinankFund) History(ctx context.Context, params *CoinankFundHistoryParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	return r.client.get(ctx, "/api/v1/coinank/fund/history", q)
}

// CoinankOrderFlow provides methods for Coinank orderFlow endpoints.
type CoinankOrderFlow struct {
	client *Client
}

// CoinankOrderFlowListsParams are the query parameters for Lists.
type CoinankOrderFlowListsParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
	ProductType string `json:"productType,omitempty"`
	TickCount string `json:"tickCount,omitempty"`
}

// Order flow data — $0.001/call
func (r *CoinankOrderFlow) Lists(ctx context.Context, params *CoinankOrderFlowListsParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	if params != nil && params.ProductType != "" {
		q["productType"] = params.ProductType
	}
	if params != nil && params.TickCount != "" {
		q["tickCount"] = params.TickCount
	}
	return r.client.get(ctx, "/api/v1/coinank/order-flow/lists", q)
}

// CoinankFundingRate provides methods for Coinank fundingRate endpoints.
type CoinankFundingRate struct {
	client *Client
}

// CoinankFundingRateHistParams are the query parameters for Hist.
type CoinankFundingRateHistParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	ExchangeType string `json:"exchangeType,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Historical funding rates (cross-exchange) — $0.001/call
func (r *CoinankFundingRate) Hist(ctx context.Context, params *CoinankFundingRateHistParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.ExchangeType != "" {
		q["exchangeType"] = params.ExchangeType
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/funding-rate/hist", q)
}

// CoinankFundingRateCurrentParams are the query parameters for Current.
type CoinankFundingRateCurrentParams struct {
	Type string `json:"type,omitempty"`
}

// Real-time funding rate rankings (type: current/day/week/month/year) — $0.001/call
func (r *CoinankFundingRate) Current(ctx context.Context, params *CoinankFundingRateCurrentParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	return r.client.get(ctx, "/api/v1/coinank/funding-rate/current", q)
}

// CoinankFundingRateAccumulatedParams are the query parameters for Accumulated.
type CoinankFundingRateAccumulatedParams struct {
	Type string `json:"type,omitempty"`
}

// Accumulated funding rates (type: day/week/month/year) — $0.001/call
func (r *CoinankFundingRate) Accumulated(ctx context.Context, params *CoinankFundingRateAccumulatedParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	return r.client.get(ctx, "/api/v1/coinank/funding-rate/accumulated", q)
}

// CoinankFundingRateIndicatorParams are the query parameters for Indicator.
type CoinankFundingRateIndicatorParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Trading pair funding rate history (VIP1) — $0.001/call
func (r *CoinankFundingRate) Indicator(ctx context.Context, params *CoinankFundingRateIndicatorParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/funding-rate/indicator", q)
}

// CoinankFundingRateKlineParams are the query parameters for Kline.
type CoinankFundingRateKlineParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Funding rate candlestick — $0.001/call
func (r *CoinankFundingRate) Kline(ctx context.Context, params *CoinankFundingRateKlineParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/funding-rate/kline", q)
}

// CoinankFundingRateWeightedParams are the query parameters for Weighted.
type CoinankFundingRateWeightedParams struct {
	BaseCoin string `json:"baseCoin,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Weighted average funding rate — $0.001/call
func (r *CoinankFundingRate) Weighted(ctx context.Context, params *CoinankFundingRateWeightedParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.BaseCoin != "" {
		q["baseCoin"] = params.BaseCoin
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/funding-rate/weighted", q)
}

// CoinankFundingRateHeatmapParams are the query parameters for Heatmap.
type CoinankFundingRateHeatmapParams struct {
	Type string `json:"type,omitempty"`
	Interval string `json:"interval,omitempty"`
}

// Funding rate heatmap (type: openInterest/marketCap) — $0.001/call
func (r *CoinankFundingRate) Heatmap(ctx context.Context, params *CoinankFundingRateHeatmapParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Type != "" {
		q["type"] = params.Type
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	return r.client.get(ctx, "/api/v1/coinank/funding-rate/heatmap", q)
}

// CoinankRsi provides methods for Coinank rsi endpoints.
type CoinankRsi struct {
	client *Client
}

// CoinankRsiListParams are the query parameters for List.
type CoinankRsiListParams struct {
	Interval string `json:"interval,omitempty"`
	Exchange string `json:"exchange,omitempty"`
}

// RSI screener (interval uppercase: 1H/4H/1D) — $0.001/call
func (r *CoinankRsi) List(ctx context.Context, params *CoinankRsiListParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	return r.client.get(ctx, "/api/v1/coinank/rsi/list", q)
}

// CoinankResource provides access to all CoinAnk API endpoints.
type CoinankResource struct {
	client *Client
	Kline *CoinankKline
	Etf *CoinankEtf
	Hyper *CoinankHyper
	Trades *CoinankTrades
	BigOrder *CoinankBigOrder
	Price *CoinankPrice
	Coin *CoinankCoin
	Longshort *CoinankLongshort
	MarketOrder *CoinankMarketOrder
	News *CoinankNews
	Indicator *CoinankIndicator
	Oi *CoinankOi
	Rank *CoinankRank
	Liquidation *CoinankLiquidation
	Orderbook *CoinankOrderbook
	Fund *CoinankFund
	OrderFlow *CoinankOrderFlow
	FundingRate *CoinankFundingRate
	Rsi *CoinankRsi
}

func newCoinankResource(c *Client) *CoinankResource {
	return &CoinankResource{
		client: c,
		Kline: &CoinankKline{client: c},
		Etf: &CoinankEtf{client: c},
		Hyper: &CoinankHyper{client: c},
		Trades: &CoinankTrades{client: c},
		BigOrder: &CoinankBigOrder{client: c},
		Price: &CoinankPrice{client: c},
		Coin: &CoinankCoin{client: c},
		Longshort: &CoinankLongshort{client: c},
		MarketOrder: &CoinankMarketOrder{client: c},
		News: &CoinankNews{client: c},
		Indicator: &CoinankIndicator{client: c},
		Oi: &CoinankOi{client: c},
		Rank: &CoinankRank{client: c},
		Liquidation: &CoinankLiquidation{client: c},
		Orderbook: &CoinankOrderbook{client: c},
		Fund: &CoinankFund{client: c},
		OrderFlow: &CoinankOrderFlow{client: c},
		FundingRate: &CoinankFundingRate{client: c},
		Rsi: &CoinankRsi{client: c},
	}
}

// CoinankNetPositionsParams are the query parameters for NetPositions.
type CoinankNetPositionsParams struct {
	Exchange string `json:"exchange,omitempty"`
	Symbol string `json:"symbol,omitempty"`
	Interval string `json:"interval,omitempty"`
	EndTime string `json:"endTime,omitempty"`
	Size string `json:"size,omitempty"`
}

// Net long/short positions historical data — $0.001/call
func (r *CoinankResource) NetPositions(ctx context.Context, params *CoinankNetPositionsParams) (json.RawMessage, error) {
	q := map[string]string{}
	if params != nil && params.Exchange != "" {
		q["exchange"] = params.Exchange
	}
	if params != nil && params.Symbol != "" {
		q["symbol"] = params.Symbol
	}
	if params != nil && params.Interval != "" {
		q["interval"] = params.Interval
	}
	if params != nil && params.EndTime != "" {
		q["endTime"] = params.EndTime
	}
	if params != nil && params.Size != "" {
		q["size"] = params.Size
	}
	return r.client.get(ctx, "/api/v1/coinank/net-positions", q)
}