nautilus-okx 0.61.0

// -------------------------------------------------------------------------------------------------
//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
//  https://nautechsystems.io
//
//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
//  You may not use this file except in compliance with the License.
//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// -------------------------------------------------------------------------------------------------

//! Data transfer objects for deserializing OKX HTTP API payloads.

use nautilus_core::serialization::deserialize_optional_decimal;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use ustr::Ustr;

use crate::common::{
    models::OKXRpiBookLevel,
    parse::{
        deserialize_empty_string_as_none, deserialize_empty_ustr_as_none,
        deserialize_optional_string_to_u64, deserialize_target_currency_as_none,
    },
};

/// Represents a trade tick from the GET /api/v5/market/trades endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXTrade {
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Trade price.
    pub px: String,
    /// Trade size.
    pub sz: String,
    /// Trade side: buy or sell.
    pub side: OKXSide,
    /// Trade ID assigned by OKX.
    pub trade_id: Ustr,
    /// Trade timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
    /// Trade source (0: normal order, 1: RPI order).
    #[serde(default)]
    pub source: Option<String>,
}

/// Represents a candlestick from the GET /api/v5/market/history-candles endpoint.
/// The tuple contains [timestamp(ms), open, high, low, close, volume, turnover, base_volume, count].
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct OKXCandlestick(
    /// Timestamp in milliseconds.
    pub String,
    /// Open price.
    pub String,
    /// High price.
    pub String,
    /// Low price.
    pub String,
    /// Close price.
    pub String,
    /// Volume.
    pub String,
    /// Turnover in quote currency.
    pub String,
    /// Base volume.
    pub String,
    /// Record count.
    pub String,
);

use crate::common::{
    enums::{
        OKXAlgoOrderStatus, OKXAlgoOrderType, OKXExecType, OKXInstrumentType, OKXMarginMode,
        OKXOrderCategory, OKXOrderStatus, OKXOrderType, OKXPositionSide, OKXSide, OKXSpreadState,
        OKXSpreadType, OKXTargetCurrency, OKXTradeMode, OKXTriggerType, OKXVipLevel,
    },
    parse::deserialize_string_to_u64,
};

/// Represents a mark price from the GET /api/v5/public/mark-price endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXMarkPrice {
    /// Underlying.
    pub uly: Option<Ustr>,
    /// Instrument ID.
    pub inst_id: Ustr,
    /// The mark price.
    pub mark_px: String,
    /// The timestamp for the mark price.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

/// Represents a price-limit row from the GET /api/v5/public/price-limit endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPriceLimit {
    /// Instrument type.
    pub inst_type: OKXInstrumentType,
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Highest buy limit price.
    pub buy_lmt: String,
    /// Lowest sell limit price.
    pub sell_lmt: String,
    /// Data timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
    /// Whether the price limit is effective.
    #[serde(default)]
    pub enabled: bool,
}

/// Represents an option summary row from the GET /api/v5/public/opt-summary endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXOptionSummary {
    /// Instrument type.
    pub inst_type: OKXInstrumentType,
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Underlying index.
    pub uly: Ustr,
    /// Bid volatility.
    pub bid_vol: String,
    /// Ask volatility.
    pub ask_vol: String,
    /// Mark volatility.
    pub mark_vol: String,
    /// Forward price.
    pub fwd_px: String,
    /// Data timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

/// Represents a spread from the GET /api/v5/sprd/spreads endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXSpread {
    /// Spread ID.
    pub sprd_id: Ustr,
    /// Spread type.
    pub sprd_type: OKXSpreadType,
    /// Spread status.
    pub state: OKXSpreadState,
    /// Base currency.
    pub base_ccy: Ustr,
    /// Size currency.
    pub sz_ccy: Ustr,
    /// Quote currency.
    pub quote_ccy: Ustr,
    /// Tick size in quote currency.
    pub tick_sz: String,
    /// Minimum order size in size currency.
    pub min_sz: String,
    /// Order size increment in size currency.
    pub lot_sz: String,
    /// Listing time in milliseconds.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub list_time: Option<u64>,
    /// Expiry time in milliseconds.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub exp_time: Option<u64>,
    /// Last update time in milliseconds.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub u_time: Option<u64>,
    /// Spread legs.
    pub legs: Vec<OKXSpreadLeg>,
}

/// Represents a leg in an OKX spread.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXSpreadLeg {
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Leg side.
    pub side: OKXSide,
}

/// Represents the request body for `POST /api/v5/sprd/order`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPlaceSpreadOrderRequest {
    /// Spread ID.
    pub sprd_id: String,
    /// Client-supplied order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cl_ord_id: Option<String>,
    /// Order tag.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
    /// Order side.
    pub side: OKXSide,
    /// Order type.
    pub ord_type: OKXOrderType,
    /// Order size.
    pub sz: String,
    /// Limit price.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub px: Option<String>,
}

/// Represents the request body for `POST /api/v5/sprd/cancel-order`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXCancelSpreadOrderRequest {
    /// Order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ord_id: Option<String>,
    /// Client-supplied order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cl_ord_id: Option<String>,
}

/// Represents the request body for `POST /api/v5/sprd/mass-cancel`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXCancelAllSpreadOrdersRequest {
    /// Spread ID.
    pub sprd_id: String,
}

/// Represents a spread order from `GET /api/v5/sprd/order` and history endpoints.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXSpreadOrder {
    /// Spread ID.
    pub sprd_id: Ustr,
    /// Order ID.
    pub ord_id: Ustr,
    /// Client order ID.
    #[serde(default)]
    pub cl_ord_id: Ustr,
    /// Order tag.
    #[serde(default)]
    pub tag: String,
    /// Order side.
    pub side: OKXSide,
    /// Order type.
    pub ord_type: OKXOrderType,
    /// Order size.
    pub sz: String,
    /// Order price.
    #[serde(default)]
    pub px: String,
    /// Average fill price.
    #[serde(default)]
    pub avg_px: String,
    /// Order state.
    pub state: OKXOrderStatus,
    /// Accumulated filled size.
    #[serde(default)]
    pub acc_fill_sz: String,
    /// Pending fill size.
    #[serde(default)]
    pub pending_fill_sz: String,
    /// Pending settlement size.
    #[serde(default)]
    pub pending_settle_sz: String,
    /// Canceled size.
    #[serde(default)]
    pub canceled_sz: String,
    /// Last fill size.
    #[serde(default)]
    pub fill_sz: String,
    /// Last fill price.
    #[serde(default)]
    pub fill_px: String,
    /// Trade ID for the last fill, if provided.
    #[serde(default)]
    pub trade_id: Ustr,
    /// Cancel source.
    #[serde(default)]
    pub cancel_source: String,
    /// Request ID for amend responses.
    #[serde(default)]
    pub req_id: String,
    /// Amend result.
    #[serde(default)]
    pub amend_result: String,
    /// Response code.
    #[serde(default)]
    pub code: String,
    /// Response message.
    #[serde(default)]
    pub msg: String,
    /// Creation time in milliseconds.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub c_time: Option<u64>,
    /// Last update time in milliseconds.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub u_time: Option<u64>,
}

/// Represents a spread trade from `GET /api/v5/sprd/trades`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXSpreadTrade {
    /// Spread ID.
    pub sprd_id: Ustr,
    /// Trade ID.
    pub trade_id: Ustr,
    /// Order ID.
    pub ord_id: Ustr,
    /// Client order ID.
    #[serde(default)]
    pub cl_ord_id: Ustr,
    /// Last filled price.
    pub fill_px: String,
    /// Last filled quantity.
    pub fill_sz: String,
    /// Trade side.
    pub side: OKXSide,
    /// Execution type.
    #[serde(default)]
    pub exec_type: OKXExecType,
    /// Fee currency.
    #[serde(default)]
    pub fee_ccy: String,
    /// Fee amount.
    #[serde(default, deserialize_with = "deserialize_empty_string_as_none")]
    pub fee: Option<String>,
    /// Timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

/// Settlement configuration for an OKX event contract series.
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXEventContractSettlement {
    /// Settlement method.
    #[serde(default)]
    pub method: String,
    /// Whether the market can settle before expiry.
    #[serde(default)]
    pub close_early: bool,
    /// Settlement source name.
    #[serde(default)]
    pub src_name: String,
    /// Price underlying in OKX symbol format.
    #[serde(default)]
    pub underlying: String,
}

/// Represents an event contract series from the GET /api/v5/public/event-contract/series endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXEventContractSeries {
    /// Series ID.
    pub series_id: String,
    /// Series frequency.
    #[serde(default)]
    pub freq: String,
    /// Series title.
    #[serde(default)]
    pub title: String,
    /// Series category.
    #[serde(default)]
    pub category: String,
    /// Settlement information.
    #[serde(default)]
    pub settlement: OKXEventContractSettlement,
}

/// Represents an event from the GET /api/v5/public/event-contract/events endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXEventContractEvent {
    /// Series ID.
    pub series_id: String,
    /// Event ID.
    pub event_id: String,
    /// Fixing time in milliseconds, if available.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub fix_time: Option<u64>,
    /// Expiry time in milliseconds.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub exp_time: Option<u64>,
    /// Event state.
    pub state: String,
}

/// Represents an event market from the GET /api/v5/public/event-contract/markets endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXEventContractMarket {
    /// Series ID.
    pub series_id: String,
    /// Event ID.
    pub event_id: String,
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Listing time in milliseconds.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub list_time: Option<u64>,
    /// Fixing time in milliseconds, if available.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub fix_time: Option<u64>,
    /// Expiry time in milliseconds.
    #[serde(default, deserialize_with = "deserialize_optional_string_to_u64")]
    pub exp_time: Option<u64>,
    /// Market state.
    pub state: String,
    /// Whether the market has been disputed.
    pub disputed: bool,
    /// Market outcome: 0 unavailable, 1 yes, 2 no.
    pub outcome: String,
    /// Minimum expiration value for a yes outcome.
    pub floor_strike: String,
    /// Settlement value when expired.
    pub settle_value: String,
}

/// Represents an index price from the GET /api/v5/public/index-tickers endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXIndexTicker {
    /// Instrument ID.
    pub inst_id: Ustr,
    /// The index price.
    pub idx_px: String,
    /// The timestamp for the index price.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

/// Represents an order book level from the GET /api/v5/market/books endpoint.
/// Each entry is a 4-element tuple: [price, size, liquidated_orders, num_orders].
pub type OKXOrderBookLevel = (String, String, String, String);

/// Represents an order book snapshot from the GET /api/v5/market/books endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXOrderBookSnapshot {
    /// Ask levels [price, size, liquidated_orders_count, orders_count].
    pub asks: Vec<OKXOrderBookLevel>,
    /// Bid levels [price, size, liquidated_orders_count, orders_count].
    pub bids: Vec<OKXOrderBookLevel>,
    /// Timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

/// Represents an order book snapshot from the GET /api/v5/market/books-rpi endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXRpiOrderBookSnapshot {
    /// Ask levels [price, total quantity, non-RPI quantity, order count].
    pub asks: Vec<OKXRpiBookLevel>,
    /// Bid levels [price, total quantity, non-RPI quantity, order count].
    pub bids: Vec<OKXRpiBookLevel>,
    /// Sequence ID of the snapshot.
    pub seq_id: u64,
    /// Timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

/// Represents a funding rate history entry from the GET /api/v5/public/funding-rate-history endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXFundingRateHistory {
    /// Instrument type.
    pub inst_type: OKXInstrumentType,
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Funding rate.
    pub funding_rate: String,
    /// Realized rate.
    pub realized_rate: String,
    /// Funding time, Unix timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub funding_time: u64,
    /// Funding rate calculation method.
    #[serde(default)]
    pub method: Option<String>,
}

/// Represents a position tier from the GET /api/v5/public/position-tiers endpoint.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPositionTier {
    /// Underlying.
    pub uly: Ustr,
    /// Instrument family.
    pub inst_family: String,
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Tier level.
    pub tier: String,
    /// Minimum size/amount for the tier.
    pub min_sz: String,
    /// Maximum size/amount for the tier.
    pub max_sz: String,
    /// Maintenance margin requirement rate.
    pub mmr: String,
    /// Initial margin requirement rate.
    pub imr: String,
    /// Maximum available leverage.
    pub max_lever: String,
    /// Option Margin Coefficient (only applicable to options).
    pub opt_mgn_factor: String,
    /// Quote currency borrowing amount.
    pub quote_max_loan: String,
    /// Base currency borrowing amount.
    pub base_max_loan: String,
}

/// Represents an account balance snapshot from `GET /api/v5/account/balance`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXAccount {
    /// Adjusted/Effective equity in USD.
    pub adj_eq: String,
    /// Borrow frozen amount.
    pub borrow_froz: String,
    /// Account details by currency.
    pub details: Vec<OKXBalanceDetail>,
    /// Initial margin requirement.
    pub imr: String,
    /// Isolated margin equity.
    pub iso_eq: String,
    /// Margin ratio.
    pub mgn_ratio: String,
    /// Maintenance margin requirement.
    pub mmr: String,
    /// Notional value in USD for borrow.
    pub notional_usd_for_borrow: String,
    /// Notional value in USD for futures.
    pub notional_usd_for_futures: String,
    /// Notional value in USD for option.
    pub notional_usd_for_option: String,
    /// Notional value in USD for swap.
    pub notional_usd_for_swap: String,
    /// Notional value in USD.
    pub notional_usd: String,
    /// Order frozen.
    pub ord_froz: String,
    /// Total equity in USD.
    pub total_eq: String,
    /// Last update time, Unix timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub u_time: u64,
    /// Unrealized profit and loss.
    pub upl: String,
}

/// Represents a balance detail for a single currency in an OKX account.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "python", pyo3::pyclass(from_py_object))]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.adapters.okx")
)]
pub struct OKXBalanceDetail {
    /// Available balance.
    pub avail_bal: String,
    /// Available equity.
    pub avail_eq: String,
    /// Borrow frozen amount.
    pub borrow_froz: String,
    /// Cash balance.
    pub cash_bal: String,
    /// Currency.
    pub ccy: Ustr,
    /// Cross liability.
    pub cross_liab: String,
    /// Discount equity in USD.
    pub dis_eq: String,
    /// Equity.
    pub eq: String,
    /// Equity in USD.
    pub eq_usd: String,
    /// Same-token equity.
    pub smt_sync_eq: String,
    /// Copy trading equity.
    pub spot_copy_trading_eq: String,
    /// Fixed balance.
    pub fixed_bal: String,
    /// Frozen balance.
    pub frozen_bal: String,
    /// Initial margin requirement.
    pub imr: String,
    /// Interest.
    pub interest: String,
    /// Isolated margin equity.
    pub iso_eq: String,
    /// Isolated margin liability.
    pub iso_liab: String,
    /// Isolated unrealized profit and loss.
    pub iso_upl: String,
    /// Liability.
    pub liab: String,
    /// Maximum loan amount.
    pub max_loan: String,
    /// Margin ratio.
    pub mgn_ratio: String,
    /// Maintenance margin requirement.
    pub mmr: String,
    /// Notional leverage.
    pub notional_lever: String,
    /// Order frozen.
    pub ord_frozen: String,
    /// Reward balance.
    pub reward_bal: String,
    /// Spot in use amount.
    #[serde(alias = "spotInUse")]
    pub spot_in_use_amt: String,
    /// Cross liability spot in use amount.
    #[serde(alias = "clSpotInUse")]
    pub cl_spot_in_use_amt: String,
    /// Maximum spot in use amount.
    #[serde(alias = "maxSpotInUse")]
    pub max_spot_in_use_amt: String,
    /// Spot isolated balance.
    pub spot_iso_bal: String,
    /// Strategy equity.
    pub stgy_eq: String,
    /// Time-weighted average price.
    pub twap: String,
    /// Last update time, Unix timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub u_time: u64,
    /// Unrealized profit and loss.
    pub upl: String,
    /// Unrealized profit and loss liability.
    pub upl_liab: String,
    /// Spot balance.
    pub spot_bal: String,
    /// Open average price.
    pub open_avg_px: String,
    /// Accumulated average price.
    pub acc_avg_px: String,
    /// Spot unrealized profit and loss.
    pub spot_upl: String,
    /// Spot unrealized profit and loss ratio.
    pub spot_upl_ratio: String,
    /// Total profit and loss.
    pub total_pnl: String,
    /// Total profit and loss ratio.
    pub total_pnl_ratio: String,
}

/// Represents a single open position from `GET /api/v5/account/positions`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPosition {
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Instrument type.
    pub inst_type: OKXInstrumentType,
    /// Margin mode: isolated/cross.
    pub mgn_mode: OKXMarginMode,
    /// Position ID.
    #[serde(default, deserialize_with = "deserialize_empty_ustr_as_none")]
    pub pos_id: Option<Ustr>,
    /// Position side: long/short.
    pub pos_side: OKXPositionSide,
    /// Position size.
    pub pos: String,
    /// Base currency balance.
    pub base_bal: String,
    /// Position currency.
    pub ccy: String,
    /// Trading fee.
    pub fee: String,
    /// Position leverage.
    pub lever: String,
    /// Last traded price.
    pub last: String,
    /// Mark price.
    pub mark_px: String,
    /// Liquidation price.
    pub liq_px: String,
    /// Maintenance margin requirement.
    pub mmr: String,
    /// Interest.
    pub interest: String,
    /// Trade ID.
    pub trade_id: Ustr,
    /// Notional value of position in USD.
    pub notional_usd: String,
    /// Average entry price.
    pub avg_px: String,
    /// Unrealized profit and loss.
    pub upl: String,
    /// Unrealized profit and loss ratio.
    pub upl_ratio: String,
    /// Last update time, Unix timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub u_time: u64,
    /// Position margin.
    pub margin: String,
    /// Margin ratio.
    pub mgn_ratio: String,
    /// Auto-deleveraging (ADL) ranking.
    pub adl: String,
    /// Creation time, Unix timestamp in milliseconds.
    pub c_time: String,
    /// Realized profit and loss.
    pub realized_pnl: String,
    /// Unrealized profit and loss at last price.
    pub upl_last_px: String,
    /// Unrealized profit and loss ratio at last price.
    pub upl_ratio_last_px: String,
    /// Available position that can be closed.
    pub avail_pos: String,
    /// Breakeven price.
    pub be_px: String,
    /// Funding fee.
    pub funding_fee: String,
    /// Index price.
    pub idx_px: String,
    /// Liquidation penalty.
    pub liq_penalty: String,
    /// Option value.
    pub opt_val: String,
    /// Pending close order liability value.
    pub pending_close_ord_liab_val: String,
    /// Total profit and loss.
    pub pnl: String,
    /// Position currency.
    pub pos_ccy: String,
    /// Quote currency balance.
    pub quote_bal: String,
    /// Borrowed amount in quote currency.
    pub quote_borrowed: String,
    /// Interest on quote currency.
    pub quote_interest: String,
    /// Amount in use for spot trading.
    #[serde(alias = "spotInUse")]
    pub spot_in_use_amt: String,
    /// Currency in use for spot trading.
    pub spot_in_use_ccy: String,
    /// USD price.
    pub usd_px: String,
    /// Black-Scholes delta in dollars, only applicable to OPTION.
    #[serde(default)]
    pub delta_bs: String,
    /// Black-Scholes gamma in dollars, only applicable to OPTION.
    #[serde(default)]
    pub gamma_bs: String,
    /// Black-Scholes theta in dollars, only applicable to OPTION.
    #[serde(default)]
    pub theta_bs: String,
    /// Black-Scholes vega in dollars, only applicable to OPTION.
    #[serde(default)]
    pub vega_bs: String,
}

/// Represents the response from `POST /api/v5/trade/order` (place order).
/// This model is designed to be flexible and handle the minimal fields that the API returns.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPlaceOrderResponse {
    /// Order ID.
    #[serde(default)]
    pub ord_id: Option<Ustr>,
    /// Client order ID.
    #[serde(default)]
    pub cl_ord_id: Option<Ustr>,
    /// Order tag.
    #[serde(default)]
    pub tag: Option<String>,
    /// Instrument ID (optional - might not be in response).
    #[serde(default)]
    pub inst_id: Option<Ustr>,
    /// Order side (optional).
    #[serde(default)]
    pub side: Option<OKXSide>,
    /// Order type (optional).
    #[serde(default)]
    pub ord_type: Option<OKXOrderType>,
    /// Order size (optional).
    #[serde(default)]
    pub sz: Option<String>,
    /// Order state (optional).
    pub state: Option<OKXOrderStatus>,
    /// Price (optional).
    #[serde(default)]
    pub px: Option<String>,
    /// Average price (optional).
    #[serde(default)]
    pub avg_px: Option<String>,
    /// Accumulated filled size.
    #[serde(default)]
    pub acc_fill_sz: Option<String>,
    /// Fill size (optional).
    #[serde(default)]
    pub fill_sz: Option<String>,
    /// Fill price (optional).
    #[serde(default)]
    pub fill_px: Option<String>,
    /// Trade ID (optional).
    #[serde(default)]
    pub trade_id: Option<Ustr>,
    /// Fill time (optional).
    #[serde(default)]
    pub fill_time: Option<String>,
    /// Fee (optional).
    #[serde(default)]
    pub fee: Option<String>,
    /// Fee currency (optional).
    #[serde(default)]
    pub fee_ccy: Option<String>,
    /// Request ID (optional).
    #[serde(default)]
    pub req_id: Option<Ustr>,
    /// Position side (optional).
    #[serde(default)]
    pub pos_side: Option<OKXPositionSide>,
    /// Reduce-only flag (optional).
    #[serde(default)]
    pub reduce_only: Option<String>,
    /// Target currency (optional).
    #[serde(default, deserialize_with = "deserialize_target_currency_as_none")]
    pub tgt_ccy: Option<OKXTargetCurrency>,
    /// Creation time.
    #[serde(default)]
    pub c_time: Option<String>,
    /// Last update time (optional).
    #[serde(default)]
    pub u_time: Option<String>,
    /// The result of the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_code: Option<String>,
    /// Error message if the request failed.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_msg: Option<String>,
    /// Detailed error code if the request failed.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sub_code: Option<String>,
}

/// Represents an attached TP/SL instruction on `POST /api/v5/trade/order`.
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXAttachAlgoOrdRequest {
    /// Client order ID for the attached TP/SL OCO object.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attach_algo_cl_ord_id: Option<String>,
    /// Stop-loss trigger price.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sl_trigger_px: Option<String>,
    /// Stop-loss order price.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sl_ord_px: Option<String>,
    /// Stop-loss trigger price type.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sl_trigger_px_type: Option<OKXTriggerType>,
    /// Take-profit trigger price.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tp_trigger_px: Option<String>,
    /// Take-profit order price.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tp_ord_px: Option<String>,
    /// Take-profit trigger price type.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tp_trigger_px_type: Option<OKXTriggerType>,
    /// Callback ratio for attached trailing stop orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback_ratio: Option<String>,
    /// Callback spread for attached trailing stop orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback_spread: Option<String>,
    /// Activation price for attached trailing stop orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_px: Option<String>,
    /// New callback ratio for amended attached trailing stop orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_callback_ratio: Option<String>,
    /// New callback spread for amended attached trailing stop orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_callback_spread: Option<String>,
    /// New activation price for amended attached trailing stop orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_active_px: Option<String>,
}

/// Represents the request body for `POST /api/v5/trade/order` (place order).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPlaceOrderRequest {
    /// Instrument ID.
    pub inst_id: String,
    /// Trade mode (cash, cross, isolated).
    pub td_mode: OKXTradeMode,
    /// Currency used for margin trading when required by OKX.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ccy: Option<String>,
    /// Client-supplied order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cl_ord_id: Option<String>,
    /// Order tag.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
    /// Order side (buy, sell).
    pub side: OKXSide,
    /// Position side for derivatives.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pos_side: Option<OKXPositionSide>,
    /// Order type.
    pub ord_type: OKXOrderType,
    /// Order size.
    pub sz: String,
    /// Limit price when required by the order type.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub px: Option<String>,
    /// Price in USD, only applicable to options. Mutually exclusive with `px` and `px_vol`.
    #[serde(rename = "pxUsd", skip_serializing_if = "Option::is_none")]
    pub px_usd: Option<String>,
    /// Price in implied volatility (1 = 100%), only applicable to options.
    /// Mutually exclusive with `px` and `px_usd`.
    #[serde(rename = "pxVol", skip_serializing_if = "Option::is_none")]
    pub px_vol: Option<String>,
    /// Reduce-only flag.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reduce_only: Option<bool>,
    /// Target currency for spot market orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tgt_ccy: Option<OKXTargetCurrency>,
    /// Attached TP/SL OCO instructions.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attach_algo_ords: Option<Vec<OKXAttachAlgoOrdRequest>>,
    /// Event contract speed bump flag. Use "1" for non-post-only EVENTS orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub speed_bump: Option<String>,
    /// Event contract market outcome: yes or no.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub outcome: Option<String>,
    /// Slippage tolerance for market orders, expressed as a decimal fraction
    /// (e.g., "0.005" for 0.5%). Supported instrument/order-type scope is
    /// venue-controlled; rejected with `54084`/`54085` if exceeded or out of
    /// the venue's accepted range. See the OKX v5 docs for the current matrix.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slippage_pct: Option<String>,
    /// Whether the order may take RPI liquidity.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rpi_taker_access: Option<bool>,
    /// Whether OKX may round the order price to an eligible RPI price.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rpi_px_round: Option<bool>,
}

/// Represents the request body for `POST /api/v5/trade/amend-order`.
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXAmendOrderRequest {
    /// Instrument ID.
    pub inst_id: String,
    /// Order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ord_id: Option<String>,
    /// Client-supplied order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cl_ord_id: Option<String>,
    /// Client-supplied request ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub req_id: Option<String>,
    /// New order size.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_sz: Option<String>,
    /// New order price.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_px: Option<String>,
    /// Whether the order may take RPI liquidity after amendment.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rpi_taker_access: Option<bool>,
    /// Whether OKX may round the amended price to an eligible RPI price.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rpi_px_round: Option<bool>,
}

/// Represents the request body for `POST /api/v5/trade/cancel-batch-orders`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXCancelOrderRequest {
    /// Instrument ID.
    pub inst_id: String,
    /// Instrument ID code (numeric). May be required per OKX deprecation notice.
    #[serde(rename = "instIdCode", skip_serializing_if = "Option::is_none")]
    pub inst_id_code: Option<u64>,
    /// Order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ord_id: Option<String>,
    /// Client-supplied order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cl_ord_id: Option<String>,
}

/// Represents a single response item from `POST /api/v5/trade/cancel-batch-orders`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXCancelOrderResponse {
    /// Order ID.
    pub ord_id: String,
    /// Client-supplied order ID.
    #[serde(default)]
    pub cl_ord_id: Option<String>,
    /// The result of the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_code: Option<String>,
    /// Error message if the request failed.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_msg: Option<String>,
    /// Response timestamp.
    #[serde(default)]
    pub ts: Option<String>,
}

pub use crate::common::models::OKXAttachedAlgoOrd;

/// Represents a single historical order record from `GET /api/v5/trade/orders-history`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXOrderHistory {
    /// Order ID.
    pub ord_id: Ustr,
    /// Client order ID.
    pub cl_ord_id: Ustr,
    /// Algo order ID (for conditional orders).
    #[serde(default)]
    pub algo_id: Option<Ustr>,
    /// Client-supplied algo order ID (for conditional orders).
    #[serde(default)]
    pub algo_cl_ord_id: Option<Ustr>,
    /// Attached child client order ID if OKX surfaces one at the top level.
    #[serde(default, deserialize_with = "deserialize_empty_string_as_none")]
    pub attach_algo_cl_ord_id: Option<String>,
    /// Attached TP/SL child orders associated with the parent order.
    #[serde(default)]
    pub attach_algo_ords: Vec<OKXAttachedAlgoOrd>,
    /// Client account ID (may be omitted by OKX).
    #[serde(default)]
    pub cl_act_id: Option<Ustr>,
    /// Order tag.
    pub tag: String,
    /// Instrument type.
    pub inst_type: OKXInstrumentType,
    /// Underlying (optional).
    pub uly: Option<Ustr>,
    /// Instrument ID.
    pub inst_id: Ustr,
    /// Order type.
    pub ord_type: OKXOrderType,
    /// Order size.
    pub sz: String,
    /// Price (optional).
    pub px: String,
    /// Price in USD (options only).
    #[serde(default)]
    pub px_usd: String,
    /// Price in implied volatility (options only).
    #[serde(default)]
    pub px_vol: String,
    /// Side.
    pub side: OKXSide,
    /// Position side.
    pub pos_side: OKXPositionSide,
    /// Trade mode.
    pub td_mode: OKXTradeMode,
    /// Reduce-only flag.
    pub reduce_only: String,
    /// Target currency (optional).
    #[serde(default, deserialize_with = "deserialize_target_currency_as_none")]
    pub tgt_ccy: Option<OKXTargetCurrency>,
    /// Order state.
    pub state: OKXOrderStatus,
    /// Average price (optional).
    pub avg_px: String,
    /// Execution fee.
    pub fee: String,
    /// Fee currency.
    pub fee_ccy: String,
    /// Filled size (optional).
    pub fill_sz: String,
    /// Fill price (optional).
    pub fill_px: String,
    /// Trade ID (optional).
    pub trade_id: Ustr,
    /// Fill time, Unix timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub fill_time: u64,
    /// Accumulated filled size.
    pub acc_fill_sz: String,
    /// Fill fee (optional, may be omitted).
    #[serde(default)]
    pub fill_fee: Option<String>,
    /// Request ID (optional).
    #[serde(default)]
    pub req_id: Option<Ustr>,
    /// Cancelled filled size (optional).
    #[serde(default)]
    pub cancel_fill_sz: Option<String>,
    /// Cancelled total size (optional).
    #[serde(default)]
    pub cancel_total_sz: Option<String>,
    /// Fee discount (optional).
    #[serde(default)]
    pub fee_discount: Option<String>,
    /// Order category (normal, liquidation, ADL, etc.).
    pub category: OKXOrderCategory,
    /// Event contract market outcome, if applicable.
    #[serde(default, deserialize_with = "deserialize_empty_string_as_none")]
    pub outcome: Option<String>,
    /// Last update time, Unix timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub u_time: u64,
    /// Creation time.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub c_time: u64,
}

/// Represents an algo order response from `/trade/order-algo-*` endpoints.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXOrderAlgo {
    /// Algo order ID assigned by OKX.
    pub algo_id: String,
    /// Client-specified algo order ID.
    #[serde(default)]
    pub algo_cl_ord_id: String,
    /// Client order ID (empty until triggered).
    #[serde(default)]
    pub cl_ord_id: String,
    /// Venue order ID (empty until triggered).
    #[serde(default)]
    pub ord_id: String,
    /// Instrument ID, e.g. `ETH-USDT-SWAP`.
    pub inst_id: Ustr,
    /// Instrument type.
    pub inst_type: OKXInstrumentType,
    /// Algo order type.
    pub ord_type: OKXAlgoOrderType,
    /// Current order state.
    pub state: OKXAlgoOrderStatus,
    /// Order side.
    pub side: OKXSide,
    /// Position side.
    pub pos_side: OKXPositionSide,
    /// Submitted size.
    #[serde(default)]
    pub sz: String,
    /// Trigger price (empty for certain algo styles).
    #[serde(default)]
    pub trigger_px: String,
    /// Trigger price type (last/mark/index).
    #[serde(default)]
    pub trigger_px_type: Option<OKXTriggerType>,
    /// Stop-loss trigger price for conditional close orders.
    #[serde(default)]
    pub sl_trigger_px: String,
    /// Stop-loss order price for conditional close orders.
    #[serde(default)]
    pub sl_ord_px: String,
    /// Stop-loss trigger price type (last/mark/index).
    #[serde(default)]
    pub sl_trigger_px_type: Option<OKXTriggerType>,
    /// Take-profit trigger price for conditional close orders.
    #[serde(default)]
    pub tp_trigger_px: String,
    /// Take-profit order price for conditional close orders.
    #[serde(default)]
    pub tp_ord_px: String,
    /// Take-profit trigger price type (last/mark/index).
    #[serde(default)]
    pub tp_trigger_px_type: Option<OKXTriggerType>,
    /// Order price (-1 indicates market execution once triggered).
    #[serde(default)]
    pub ord_px: String,
    /// Trade mode (cash/cross/isolated).
    pub td_mode: OKXTradeMode,
    /// Algo leverage configuration.
    #[serde(default)]
    pub lever: String,
    /// Reduce-only flag.
    #[serde(default)]
    pub reduce_only: String,
    /// Fraction of the position to close for close-order algos.
    #[serde(default)]
    pub close_fraction: String,
    /// Executed price (if triggered).
    #[serde(default)]
    pub actual_px: String,
    /// Executed size (if triggered).
    #[serde(default)]
    pub actual_sz: String,
    /// Notional value in USD.
    #[serde(default)]
    pub notional_usd: String,
    /// Creation time (milliseconds).
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub c_time: u64,
    /// Last update time (milliseconds).
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub u_time: u64,
    /// Trigger timestamp (if triggered).
    #[serde(default)]
    pub trigger_time: String,
    /// Optional tag supplied during submission.
    #[serde(default)]
    pub tag: String,
    /// Callback price ratio for trailing stop (e.g. "0.01" for 1%).
    #[serde(default)]
    pub callback_ratio: String,
    /// Callback price spread for trailing stop (absolute distance).
    #[serde(default)]
    pub callback_spread: String,
    /// Activation price for trailing stop.
    #[serde(default)]
    pub active_px: String,
}

/// Represents a transaction detail (fill) from `GET /api/v5/trade/fills`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXTransactionDetail {
    /// Product type (SPOT, MARGIN, SWAP, FUTURES, OPTION).
    pub inst_type: OKXInstrumentType,
    /// Instrument ID, e.g. "BTC-USDT".
    pub inst_id: Ustr,
    /// Trade ID.
    pub trade_id: Ustr,
    /// Order ID.
    pub ord_id: Ustr,
    /// Client order ID.
    pub cl_ord_id: Ustr,
    /// Bill ID.
    pub bill_id: Ustr,
    /// Last filled price.
    pub fill_px: String,
    /// Last filled quantity.
    pub fill_sz: String,
    /// Trade side: buy or sell.
    pub side: OKXSide,
    /// Execution type.
    pub exec_type: OKXExecType,
    /// Fee currency.
    pub fee_ccy: String,
    /// Fee amount.
    #[serde(default, deserialize_with = "deserialize_empty_string_as_none")]
    pub fee: Option<String>,
    /// Timestamp, Unix timestamp format in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

/// Represents a single historical position record from `GET /api/v5/account/positions-history`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPositionHistory {
    /// Instrument type (e.g. "SWAP", "FUTURES", etc.).
    pub inst_type: OKXInstrumentType,
    /// Instrument ID (e.g. "BTC-USD-SWAP").
    pub inst_id: Ustr,
    /// Margin mode: e.g. "cross", "isolated".
    pub mgn_mode: OKXMarginMode,
    /// The type of the last close, e.g. "1" (close partially), "2" (close all), etc.
    /// See OKX docs for the meaning of each numeric code.
    #[serde(rename = "type")]
    pub r#type: Ustr,
    /// Creation time of the position (Unix timestamp in milliseconds).
    pub c_time: String,
    /// Last update time, Unix timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub u_time: u64,
    /// Average price of opening position.
    pub open_avg_px: String,
    /// Average price of closing position (if applicable).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub close_avg_px: Option<String>,
    /// The position ID.
    #[serde(default, deserialize_with = "deserialize_empty_ustr_as_none")]
    pub pos_id: Option<Ustr>,
    /// Max quantity of the position at open time.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub open_max_pos: Option<String>,
    /// Cumulative closed volume of the position.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub close_total_pos: Option<String>,
    /// Realized profit and loss (only for FUTURES/SWAP/OPTION).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub realized_pnl: Option<String>,
    /// Accumulated fee for the position.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fee: Option<String>,
    /// Accumulated funding fee (for perpetual swaps).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funding_fee: Option<String>,
    /// Accumulated liquidation penalty. Negative if there was a penalty.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub liq_penalty: Option<String>,
    /// Profit and loss (realized or unrealized depending on status).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pnl: Option<String>,
    /// PnL ratio.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pnl_ratio: Option<String>,
    /// Position side: "long" / "short" / "net".
    pub pos_side: OKXPositionSide,
    /// Leverage used (the JSON field is "lev", but we rename it in Rust).
    pub lever: String,
    /// Direction: "long" or "short" (only for MARGIN/FUTURES/SWAP/OPTION).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub direction: Option<String>,
    /// Trigger mark price. Populated if `type` indicates liquidation or ADL.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trigger_px: Option<String>,
    /// The underlying (e.g. "BTC-USD" for futures or swap).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uly: Option<String>,
    /// Currency (e.g. "BTC"). May or may not appear in all responses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ccy: Option<String>,
}

/// Represents the request body for `POST /api/v5/trade/order-algo` (place algo order).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPlaceAlgoOrderRequest {
    /// Instrument ID.
    #[serde(rename = "instId")]
    pub inst_id: String,
    /// Instrument ID code (numeric). May be required per OKX deprecation notice.
    #[serde(rename = "instIdCode", skip_serializing_if = "Option::is_none")]
    pub inst_id_code: Option<u64>,
    /// Trade mode (isolated, cross, cash).
    #[serde(rename = "tdMode")]
    pub td_mode: OKXTradeMode,
    /// Order side (buy, sell).
    pub side: OKXSide,
    /// Algo order type (trigger, conditional, move_order_stop, etc.).
    #[serde(rename = "ordType")]
    pub ord_type: OKXAlgoOrderType,
    /// Order size. Omitted for `closeFraction` close orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sz: Option<String>,
    /// Client-supplied algo order ID.
    #[serde(rename = "algoClOrdId", skip_serializing_if = "Option::is_none")]
    pub algo_cl_ord_id: Option<String>,
    /// Trigger price.
    #[serde(rename = "triggerPx", skip_serializing_if = "Option::is_none")]
    pub trigger_px: Option<String>,
    /// Order price (for limit orders).
    #[serde(rename = "orderPx", skip_serializing_if = "Option::is_none")]
    pub order_px: Option<String>,
    /// Trigger type (last, mark, index).
    #[serde(rename = "triggerPxType", skip_serializing_if = "Option::is_none")]
    pub trigger_px_type: Option<OKXTriggerType>,
    /// Stop-loss trigger price for conditional close orders.
    #[serde(rename = "slTriggerPx", skip_serializing_if = "Option::is_none")]
    pub sl_trigger_px: Option<String>,
    /// Stop-loss order price for conditional close orders.
    #[serde(rename = "slOrdPx", skip_serializing_if = "Option::is_none")]
    pub sl_ord_px: Option<String>,
    /// Stop-loss trigger type (last, mark, index).
    #[serde(rename = "slTriggerPxType", skip_serializing_if = "Option::is_none")]
    pub sl_trigger_px_type: Option<OKXTriggerType>,
    /// Take-profit trigger price for conditional close orders.
    #[serde(rename = "tpTriggerPx", skip_serializing_if = "Option::is_none")]
    pub tp_trigger_px: Option<String>,
    /// Take-profit order price for conditional close orders.
    #[serde(rename = "tpOrdPx", skip_serializing_if = "Option::is_none")]
    pub tp_ord_px: Option<String>,
    /// Take-profit trigger type (last, mark, index).
    #[serde(rename = "tpTriggerPxType", skip_serializing_if = "Option::is_none")]
    pub tp_trigger_px_type: Option<OKXTriggerType>,
    /// Target currency (base_ccy or quote_ccy).
    #[serde(rename = "tgtCcy", skip_serializing_if = "Option::is_none")]
    pub tgt_ccy: Option<OKXTargetCurrency>,
    /// Position side (net, long, short).
    #[serde(rename = "posSide", skip_serializing_if = "Option::is_none")]
    pub pos_side: Option<OKXPositionSide>,
    /// Whether to close position.
    #[serde(rename = "closePosition", skip_serializing_if = "Option::is_none")]
    pub close_position: Option<bool>,
    /// Order tag.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
    /// Whether it's a reduce-only order.
    #[serde(rename = "reduceOnly", skip_serializing_if = "Option::is_none")]
    pub reduce_only: Option<bool>,
    /// Fraction of the position to close for eligible algo close orders.
    #[serde(rename = "closeFraction", skip_serializing_if = "Option::is_none")]
    pub close_fraction: Option<String>,
    /// Callback rate for trailing stop (e.g., "0.01" for 1%). Either this or
    /// `callback_spread` is required for `move_order_stop` orders.
    #[serde(rename = "callbackRatio", skip_serializing_if = "Option::is_none")]
    pub callback_ratio: Option<String>,
    /// Callback spread for trailing stop (fixed price distance). Either this or
    /// `callback_ratio` is required for `move_order_stop` orders.
    #[serde(rename = "callbackSpread", skip_serializing_if = "Option::is_none")]
    pub callback_spread: Option<String>,
    /// Activation price for trailing stop. If empty, the trailing stop
    /// activates immediately when placed.
    #[serde(rename = "activePx", skip_serializing_if = "Option::is_none")]
    pub active_px: Option<String>,
}

/// Represents the response from `POST /api/v5/trade/order-algo` (place algo order).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXPlaceAlgoOrderResponse {
    /// Algo order ID.
    pub algo_id: String,
    /// Client-supplied algo order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algo_cl_ord_id: Option<String>,
    /// The result of the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_code: Option<String>,
    /// Error message if the request failed.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_msg: Option<String>,
    /// Request ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub req_id: Option<String>,
}

/// Represents the request body for `POST /api/v5/trade/cancel-algos` (cancel algo order).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXCancelAlgoOrderRequest {
    /// Instrument ID.
    pub inst_id: String,
    /// Instrument ID code (numeric). May be required per OKX deprecation notice.
    #[serde(rename = "instIdCode", skip_serializing_if = "Option::is_none")]
    pub inst_id_code: Option<u64>,
    /// Algo order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algo_id: Option<String>,
    /// Client-supplied algo order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algo_cl_ord_id: Option<String>,
}

/// Represents the response from `POST /api/v5/trade/cancel-algos` (cancel algo order).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXCancelAlgoOrderResponse {
    /// Algo order ID.
    pub algo_id: String,
    /// The result of the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_code: Option<String>,
    /// Error message if the request failed.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_msg: Option<String>,
}

/// Represents the request body for `POST /api/v5/trade/amend-algos` (amend algo order).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXAmendAlgoOrderRequest {
    /// Instrument ID.
    pub inst_id: String,
    /// Algo order ID.
    pub algo_id: String,
    /// Client-supplied algo order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algo_cl_ord_id: Option<String>,
    /// New order size.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_sz: Option<String>,
    /// New trigger price (for `trigger` algo orders).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_trigger_px: Option<String>,
    /// New take-profit trigger price (for attached/OCO TP legs).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_tp_trigger_px: Option<String>,
    /// New take-profit order price (`-1` for market).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_tp_ord_px: Option<String>,
    /// New take-profit trigger price type (last, mark, index).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_tp_trigger_px_type: Option<String>,
    /// New stop-loss trigger price (for `conditional` SL algo orders, incl.
    /// `closeFraction` close-position stops, which OKX amends via `newSlTriggerPx`
    /// rather than `newTriggerPx`).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_sl_trigger_px: Option<String>,
    /// New stop-loss order price (`-1` for market).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_sl_ord_px: Option<String>,
    /// New stop-loss trigger price type (last, mark, index).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_sl_trigger_px_type: Option<String>,
    /// New order price (for limit orders after trigger).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_order_px: Option<String>,
    /// New callback ratio for trailing stop (e.g., "0.01" for 1%).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_callback_ratio: Option<String>,
    /// New callback spread for trailing stop (fixed price distance).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_callback_spread: Option<String>,
    /// New activation price for trailing stop.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_active_px: Option<String>,
}

/// Represents the response from `POST /api/v5/trade/amend-algos` (amend algo order).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXAmendAlgoOrderResponse {
    /// Algo order ID.
    pub algo_id: String,
    /// Client-supplied algo order ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub algo_cl_ord_id: Option<String>,
    /// The result of the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_code: Option<String>,
    /// Error message if the request failed.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub s_msg: Option<String>,
    /// Request ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub req_id: Option<String>,
}

/// Represents the response from `GET /api/v5/public/time` (get system time).
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXServerTime {
    /// Server timestamp in milliseconds.
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

/// Represents a fee rate entry from `GET /api/v5/account/trade-fee`.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OKXFeeRate {
    /// Fee level (VIP tier) - indicates the user's VIP tier (0-9).
    #[serde(deserialize_with = "crate::common::parse::deserialize_vip_level")]
    pub level: OKXVipLevel,
    /// Taker fee rate for crypto-margined contracts.
    pub taker: String,
    /// Maker fee rate for crypto-margined contracts.
    pub maker: String,
    /// Taker fee rate for USDT-margined contracts.
    pub taker_u: String,
    /// Maker fee rate for USDT-margined contracts.
    pub maker_u: String,
    /// Maker fee rate for RPI orders.
    #[serde(
        default,
        alias = "elpMaker",
        deserialize_with = "deserialize_optional_decimal"
    )]
    pub rpi_maker: Option<Decimal>,
    /// Delivery fee rate.
    #[serde(default)]
    pub delivery: String,
    /// Option exercise fee rate.
    #[serde(default)]
    pub exercise: String,
    /// Event contract settlement fee rate.
    #[serde(default)]
    pub settle: String,
    /// Instrument type (SPOT, MARGIN, SWAP, FUTURES, OPTION).
    pub inst_type: OKXInstrumentType,
    /// Fee schedule category (being deprecated).
    #[serde(default)]
    pub category: String,
    /// Data return timestamp (Unix timestamp in milliseconds).
    #[serde(deserialize_with = "deserialize_string_to_u64")]
    pub ts: u64,
}

#[cfg(test)]
mod tests {
    use rstest::rstest;
    use serde_json;

    use super::*;

    #[rstest]
    fn test_algo_order_request_serialization() {
        let request = OKXPlaceAlgoOrderRequest {
            inst_id: "ETH-USDT-SWAP".to_string(),
            inst_id_code: None,
            td_mode: OKXTradeMode::Isolated,
            side: OKXSide::Buy,
            ord_type: OKXAlgoOrderType::Trigger,
            sz: Some("0.01".to_string()),
            algo_cl_ord_id: Some("test123".to_string()),
            trigger_px: Some("3000".to_string()),
            order_px: Some("-1".to_string()),
            trigger_px_type: Some(OKXTriggerType::Last),
            sl_trigger_px: None,
            sl_ord_px: None,
            sl_trigger_px_type: None,
            tp_trigger_px: None,
            tp_ord_px: None,
            tp_trigger_px_type: None,
            tgt_ccy: None,
            pos_side: None,
            close_position: None,
            tag: None,
            reduce_only: None,
            close_fraction: None,
            callback_ratio: None,
            callback_spread: None,
            active_px: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        // Verify that fields are serialized with correct camelCase names
        assert!(json.contains("\"instId\":\"ETH-USDT-SWAP\""));
        assert!(json.contains("\"tdMode\":\"isolated\""));
        assert!(json.contains("\"ordType\":\"trigger\""));
        assert!(json.contains("\"algoClOrdId\":\"test123\""));
        assert!(json.contains("\"triggerPx\":\"3000\""));
        assert!(json.contains("\"orderPx\":\"-1\""));
        assert!(json.contains("\"triggerPxType\":\"last\""));

        // Verify that None fields are not included
        assert!(!json.contains("tgtCcy"));
        assert!(!json.contains("posSide"));
        assert!(!json.contains("closePosition"));
        assert!(!json.contains("closeFraction"));
    }

    #[rstest]
    fn test_amend_algo_order_request_serializes_sl_trigger_px() {
        // A conditional stop-loss algo order (incl. closeFraction stops) is amended
        // via `newSlTriggerPx`, not `newTriggerPx`. Verify the camelCase field name
        // and that an unset `new_trigger_px` is omitted.
        let request = OKXAmendAlgoOrderRequest {
            inst_id: "ETH-USDT-SWAP".to_string(),
            algo_id: "123".to_string(),
            algo_cl_ord_id: None,
            new_sz: None,
            new_trigger_px: None,
            new_tp_trigger_px: None,
            new_tp_ord_px: None,
            new_tp_trigger_px_type: None,
            new_sl_trigger_px: Some("850".to_string()),
            new_sl_ord_px: None,
            new_sl_trigger_px_type: None,
            new_order_px: None,
            new_callback_ratio: None,
            new_callback_spread: None,
            new_active_px: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"algoId\":\"123\""));
        assert!(json.contains("\"newSlTriggerPx\":\"850\""));
        // Unset optional fields must be omitted (OKX rejects an empty newTriggerPx).
        assert!(!json.contains("newTriggerPx"));
        assert!(!json.contains("newSz"));
        assert!(!json.contains("algoClOrdId"));
    }

    #[rstest]
    fn test_amend_algo_order_request_serializes_oco_tp_sl_fields() {
        let request = OKXAmendAlgoOrderRequest {
            inst_id: "DOGE-USDT-SWAP".to_string(),
            algo_id: "algo-oco-1".to_string(),
            algo_cl_ord_id: None,
            new_sz: None,
            new_trigger_px: None,
            new_tp_trigger_px: Some("0.10495".to_string()),
            new_tp_ord_px: Some("-1".to_string()),
            new_tp_trigger_px_type: Some("last".to_string()),
            new_sl_trigger_px: Some("0.06297".to_string()),
            new_sl_ord_px: Some("-1".to_string()),
            new_sl_trigger_px_type: Some("last".to_string()),
            new_order_px: None,
            new_callback_ratio: None,
            new_callback_spread: None,
            new_active_px: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"algoId\":\"algo-oco-1\""));
        assert!(json.contains("\"newTpTriggerPx\":\"0.10495\""));
        assert!(json.contains("\"newTpOrdPx\":\"-1\""));
        assert!(json.contains("\"newTpTriggerPxType\":\"last\""));
        assert!(json.contains("\"newSlTriggerPx\":\"0.06297\""));
        assert!(json.contains("\"newSlOrdPx\":\"-1\""));
        assert!(json.contains("\"newSlTriggerPxType\":\"last\""));
        assert!(!json.contains("newTriggerPx"));
    }

    #[rstest]
    fn test_algo_order_request_serializes_close_fraction() {
        let request = OKXPlaceAlgoOrderRequest {
            inst_id: "ETH-USDT-SWAP".to_string(),
            inst_id_code: None,
            td_mode: OKXTradeMode::Cross,
            side: OKXSide::Sell,
            ord_type: OKXAlgoOrderType::Conditional,
            sz: None,
            algo_cl_ord_id: Some("close-frac-123".to_string()),
            trigger_px: None,
            order_px: None,
            trigger_px_type: None,
            sl_trigger_px: Some("3000".to_string()),
            sl_ord_px: Some("-1".to_string()),
            sl_trigger_px_type: Some(OKXTriggerType::Last),
            tp_trigger_px: None,
            tp_ord_px: None,
            tp_trigger_px_type: None,
            tgt_ccy: None,
            pos_side: Some(OKXPositionSide::Net),
            close_position: None,
            tag: None,
            reduce_only: Some(true),
            close_fraction: Some("1".to_string()),
            callback_ratio: None,
            callback_spread: None,
            active_px: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"ordType\":\"conditional\""));
        assert!(json.contains("\"closeFraction\":\"1\""));
        assert!(json.contains("\"slTriggerPx\":\"3000\""));
        assert!(json.contains("\"slOrdPx\":\"-1\""));
        assert!(json.contains("\"slTriggerPxType\":\"last\""));
        assert!(json.contains("\"reduceOnly\":true"));
        assert!(!json.contains("\"sz\""));
        assert!(!json.contains("triggerPx"));
    }

    #[rstest]
    fn test_algo_order_request_array_serialization() {
        let request = OKXPlaceAlgoOrderRequest {
            inst_id: "BTC-USDT".to_string(),
            inst_id_code: Some(10459),
            td_mode: OKXTradeMode::Cross,
            side: OKXSide::Sell,
            ord_type: OKXAlgoOrderType::Trigger,
            sz: Some("0.1".to_string()),
            algo_cl_ord_id: None,
            trigger_px: Some("50000".to_string()),
            order_px: Some("49900".to_string()),
            trigger_px_type: Some(OKXTriggerType::Mark),
            sl_trigger_px: None,
            sl_ord_px: None,
            sl_trigger_px_type: None,
            tp_trigger_px: None,
            tp_ord_px: None,
            tp_trigger_px_type: None,
            tgt_ccy: Some(OKXTargetCurrency::BaseCcy),
            pos_side: Some(OKXPositionSide::Net),
            close_position: None,
            tag: None,
            reduce_only: Some(true),
            close_fraction: None,
            callback_ratio: None,
            callback_spread: None,
            active_px: None,
        };

        // OKX expects an array of requests
        let json = serde_json::to_string(&[request]).unwrap();

        // Verify array format
        assert!(json.starts_with('['));
        assert!(json.ends_with(']'));

        // Verify correct field names
        assert!(json.contains("\"instId\":\"BTC-USDT\""));
        assert!(json.contains("\"tdMode\":\"cross\""));
        assert!(json.contains("\"triggerPx\":\"50000\""));
        assert!(json.contains("\"orderPx\":\"49900\""));
        assert!(json.contains("\"triggerPxType\":\"mark\""));
        assert!(json.contains("\"tgtCcy\":\"base_ccy\""));
        assert!(json.contains("\"posSide\":\"net\""));
        assert!(json.contains("\"reduceOnly\":true"));
    }

    #[rstest]
    fn test_cancel_algo_order_request_serialization() {
        let request = OKXCancelAlgoOrderRequest {
            inst_id: "ETH-USDT-SWAP".to_string(),
            inst_id_code: None,
            algo_id: Some("123456".to_string()),
            algo_cl_ord_id: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        // Verify correct field names
        assert!(json.contains("\"instId\":\"ETH-USDT-SWAP\""));
        assert!(json.contains("\"algoId\":\"123456\""));
        assert!(!json.contains("algoClOrdId"));
    }

    #[rstest]
    fn test_cancel_algo_order_with_client_id_serialization() {
        let request = OKXCancelAlgoOrderRequest {
            inst_id: "BTC-USDT".to_string(),
            inst_id_code: Some(10459),
            algo_id: None,
            algo_cl_ord_id: Some("client123".to_string()),
        };

        // OKX expects an array of requests
        let json = serde_json::to_string(&[request]).unwrap();

        // Verify array format and field names
        assert!(json.starts_with('['));
        assert!(json.contains("\"instId\":\"BTC-USDT\""));
        assert!(json.contains("\"algoClOrdId\":\"client123\""));
        assert!(!json.contains("\"algoId\""));
    }

    #[rstest]
    fn test_amend_algo_order_trigger_serialization() {
        let request = OKXAmendAlgoOrderRequest {
            inst_id: "ETH-USDT-SWAP".to_string(),
            algo_id: "123456".to_string(),
            algo_cl_ord_id: None,
            new_sz: None,
            new_trigger_px: Some("3500".to_string()),
            new_tp_trigger_px: None,
            new_tp_ord_px: None,
            new_tp_trigger_px_type: None,
            new_sl_trigger_px: None,
            new_sl_ord_px: None,
            new_sl_trigger_px_type: None,
            new_order_px: Some("3490".to_string()),
            new_callback_ratio: None,
            new_callback_spread: None,
            new_active_px: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"instId\":\"ETH-USDT-SWAP\""));
        assert!(json.contains("\"algoId\":\"123456\""));
        assert!(json.contains("\"newTriggerPx\":\"3500\""));
        assert!(json.contains("\"newOrderPx\":\"3490\""));
        assert!(!json.contains("newSz"));
        assert!(!json.contains("algoClOrdId"));
        assert!(!json.contains("newCallbackRatio"));
    }

    #[rstest]
    fn test_amend_algo_order_trailing_stop_serialization() {
        let request = OKXAmendAlgoOrderRequest {
            inst_id: "BTC-USDT-SWAP".to_string(),
            algo_id: "789012".to_string(),
            algo_cl_ord_id: Some("client456".to_string()),
            new_sz: Some("0.1".to_string()),
            new_trigger_px: None,
            new_tp_trigger_px: None,
            new_tp_ord_px: None,
            new_tp_trigger_px_type: None,
            new_sl_trigger_px: None,
            new_sl_ord_px: None,
            new_sl_trigger_px_type: None,
            new_order_px: None,
            new_callback_ratio: Some("0.02".to_string()),
            new_callback_spread: None,
            new_active_px: Some("50000".to_string()),
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"instId\":\"BTC-USDT-SWAP\""));
        assert!(json.contains("\"algoId\":\"789012\""));
        assert!(json.contains("\"algoClOrdId\":\"client456\""));
        assert!(json.contains("\"newSz\":\"0.1\""));
        assert!(json.contains("\"newCallbackRatio\":\"0.02\""));
        assert!(json.contains("\"newActivePx\":\"50000\""));
        assert!(!json.contains("newTriggerPx"));
        assert!(!json.contains("newOrderPx"));
    }

    #[rstest]
    fn test_trailing_stop_request_callback_ratio_serialization() {
        let request = OKXPlaceAlgoOrderRequest {
            inst_id: "BTC-USDT-SWAP".to_string(),
            inst_id_code: None,
            td_mode: OKXTradeMode::Cross,
            side: OKXSide::Buy,
            ord_type: OKXAlgoOrderType::MoveOrderStop,
            sz: Some("0.1".to_string()),
            algo_cl_ord_id: Some("trail-001".to_string()),
            trigger_px: None,
            order_px: None,
            trigger_px_type: None,
            sl_trigger_px: None,
            sl_ord_px: None,
            sl_trigger_px_type: None,
            tp_trigger_px: None,
            tp_ord_px: None,
            tp_trigger_px_type: None,
            tgt_ccy: None,
            pos_side: None,
            close_position: None,
            tag: None,
            reduce_only: None,
            close_fraction: None,
            callback_ratio: Some("0.01".to_string()),
            callback_spread: None,
            active_px: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"ordType\":\"move_order_stop\""));
        assert!(json.contains("\"callbackRatio\":\"0.01\""));
        assert!(!json.contains("callbackSpread"));
        assert!(!json.contains("activePx"));
    }

    #[rstest]
    fn test_trailing_stop_request_callback_spread_serialization() {
        let request = OKXPlaceAlgoOrderRequest {
            inst_id: "ETH-USDT-SWAP".to_string(),
            inst_id_code: None,
            td_mode: OKXTradeMode::Isolated,
            side: OKXSide::Sell,
            ord_type: OKXAlgoOrderType::MoveOrderStop,
            sz: Some("1.0".to_string()),
            algo_cl_ord_id: None,
            trigger_px: None,
            order_px: None,
            trigger_px_type: None,
            sl_trigger_px: None,
            sl_ord_px: None,
            sl_trigger_px_type: None,
            tp_trigger_px: None,
            tp_ord_px: None,
            tp_trigger_px_type: None,
            tgt_ccy: None,
            pos_side: None,
            close_position: None,
            tag: None,
            reduce_only: Some(true),
            close_fraction: None,
            callback_ratio: None,
            callback_spread: Some("50.5".to_string()),
            active_px: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"callbackSpread\":\"50.5\""));
        assert!(!json.contains("callbackRatio"));
        assert!(!json.contains("activePx"));
    }

    #[rstest]
    fn test_trailing_stop_request_with_activation_price_serialization() {
        let request = OKXPlaceAlgoOrderRequest {
            inst_id: "BTC-USDT-SWAP".to_string(),
            inst_id_code: None,
            td_mode: OKXTradeMode::Cross,
            side: OKXSide::Buy,
            ord_type: OKXAlgoOrderType::MoveOrderStop,
            sz: Some("0.5".to_string()),
            algo_cl_ord_id: None,
            trigger_px: None,
            order_px: None,
            trigger_px_type: None,
            sl_trigger_px: None,
            sl_ord_px: None,
            sl_trigger_px_type: None,
            tp_trigger_px: None,
            tp_ord_px: None,
            tp_trigger_px_type: None,
            tgt_ccy: None,
            pos_side: None,
            close_position: None,
            tag: None,
            reduce_only: None,
            close_fraction: None,
            callback_ratio: Some("0.005".to_string()),
            callback_spread: None,
            active_px: Some("65000".to_string()),
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"callbackRatio\":\"0.005\""));
        assert!(json.contains("\"activePx\":\"65000\""));
        assert!(!json.contains("callbackSpread"));
    }

    #[rstest]
    fn test_amend_algo_order_callback_spread_serialization() {
        let request = OKXAmendAlgoOrderRequest {
            inst_id: "ETH-USDT-SWAP".to_string(),
            algo_id: "456789".to_string(),
            algo_cl_ord_id: None,
            new_sz: None,
            new_trigger_px: None,
            new_tp_trigger_px: None,
            new_tp_ord_px: None,
            new_tp_trigger_px_type: None,
            new_sl_trigger_px: None,
            new_sl_ord_px: None,
            new_sl_trigger_px_type: None,
            new_order_px: None,
            new_callback_ratio: None,
            new_callback_spread: Some("25.0".to_string()),
            new_active_px: Some("4000".to_string()),
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"newCallbackSpread\":\"25.0\""));
        assert!(json.contains("\"newActivePx\":\"4000\""));
        assert!(!json.contains("newCallbackRatio"));
        assert!(!json.contains("newTriggerPx"));
        assert!(!json.contains("newSz"));
    }

    #[rstest]
    fn test_amend_algo_order_size_only_serialization() {
        let request = OKXAmendAlgoOrderRequest {
            inst_id: "BTC-USDT-SWAP".to_string(),
            algo_id: "111222".to_string(),
            algo_cl_ord_id: None,
            new_sz: Some("0.5".to_string()),
            new_trigger_px: None,
            new_tp_trigger_px: None,
            new_tp_ord_px: None,
            new_tp_trigger_px_type: None,
            new_sl_trigger_px: None,
            new_sl_ord_px: None,
            new_sl_trigger_px_type: None,
            new_order_px: None,
            new_callback_ratio: None,
            new_callback_spread: None,
            new_active_px: None,
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"newSz\":\"0.5\""));
        assert!(!json.contains("newTriggerPx"));
        assert!(!json.contains("newOrderPx"));
        assert!(!json.contains("newCallbackRatio"));
        assert!(!json.contains("newCallbackSpread"));
        assert!(!json.contains("newActivePx"));
    }

    #[rstest]
    fn test_amend_algo_order_all_fields_serialization() {
        let request = OKXAmendAlgoOrderRequest {
            inst_id: "BTC-USDT-SWAP".to_string(),
            algo_id: "333444".to_string(),
            algo_cl_ord_id: Some("client789".to_string()),
            new_sz: Some("1.0".to_string()),
            new_trigger_px: Some("60000".to_string()),
            new_tp_trigger_px: None,
            new_tp_ord_px: None,
            new_tp_trigger_px_type: None,
            new_sl_trigger_px: None,
            new_sl_ord_px: None,
            new_sl_trigger_px_type: None,
            new_order_px: Some("59900".to_string()),
            new_callback_ratio: Some("0.015".to_string()),
            new_callback_spread: Some("100".to_string()),
            new_active_px: Some("62000".to_string()),
        };

        let json = serde_json::to_string(&request).unwrap();

        assert!(json.contains("\"instId\":\"BTC-USDT-SWAP\""));
        assert!(json.contains("\"algoId\":\"333444\""));
        assert!(json.contains("\"algoClOrdId\":\"client789\""));
        assert!(json.contains("\"newSz\":\"1.0\""));
        assert!(json.contains("\"newTriggerPx\":\"60000\""));
        assert!(json.contains("\"newOrderPx\":\"59900\""));
        assert!(json.contains("\"newCallbackRatio\":\"0.015\""));
        assert!(json.contains("\"newCallbackSpread\":\"100\""));
        assert!(json.contains("\"newActivePx\":\"62000\""));
    }

    #[rstest]
    fn test_place_order_request_serializes_px_usd() {
        let request = OKXPlaceOrderRequest {
            inst_id: "BTC-USD-250328-50000-C".to_string(),
            td_mode: OKXTradeMode::Cross,
            ccy: None,
            cl_ord_id: Some("test-opt-1".to_string()),
            tag: None,
            side: OKXSide::Buy,
            pos_side: Some(OKXPositionSide::Net),
            ord_type: OKXOrderType::Limit,
            sz: "1".to_string(),
            px: None,
            px_usd: Some("100.5".to_string()),
            px_vol: None,
            reduce_only: None,
            tgt_ccy: None,
            attach_algo_ords: None,
            speed_bump: None,
            outcome: None,
            slippage_pct: None,
            rpi_taker_access: None,
            rpi_px_round: None,
        };

        let json = serde_json::to_string(&request).unwrap();
        assert!(json.contains("\"pxUsd\":\"100.5\""));
        assert!(!json.contains("\"pxVol\""));
        assert!(!json.contains("\"px\":"));
        assert!(!json.contains("slippagePct"));
    }

    #[rstest]
    fn test_place_order_request_serializes_px_vol() {
        let request = OKXPlaceOrderRequest {
            inst_id: "BTC-USD-250328-50000-C".to_string(),
            td_mode: OKXTradeMode::Cross,
            ccy: None,
            cl_ord_id: Some("test-opt-2".to_string()),
            tag: None,
            side: OKXSide::Buy,
            pos_side: Some(OKXPositionSide::Net),
            ord_type: OKXOrderType::Limit,
            sz: "1".to_string(),
            px: None,
            px_usd: None,
            px_vol: Some("0.55".to_string()),
            reduce_only: None,
            tgt_ccy: None,
            attach_algo_ords: None,
            speed_bump: None,
            outcome: None,
            slippage_pct: None,
            rpi_taker_access: None,
            rpi_px_round: None,
        };

        let json = serde_json::to_string(&request).unwrap();
        assert!(json.contains("\"pxVol\":\"0.55\""));
        assert!(!json.contains("\"pxUsd\""));
        assert!(!json.contains("\"px\":"));
    }

    #[rstest]
    fn test_place_order_request_serializes_slippage_pct() {
        let request = OKXPlaceOrderRequest {
            inst_id: "BTC-USDT-SWAP".to_string(),
            td_mode: OKXTradeMode::Cross,
            ccy: None,
            cl_ord_id: Some("mkt-slip-1".to_string()),
            tag: None,
            side: OKXSide::Buy,
            pos_side: Some(OKXPositionSide::Net),
            ord_type: OKXOrderType::Market,
            sz: "1".to_string(),
            px: None,
            px_usd: None,
            px_vol: None,
            reduce_only: None,
            tgt_ccy: None,
            attach_algo_ords: None,
            speed_bump: None,
            outcome: None,
            slippage_pct: Some("0.005".to_string()),
            rpi_taker_access: None,
            rpi_px_round: None,
        };

        let json: serde_json::Value = serde_json::to_value(&request).unwrap();
        assert_eq!(json["slippagePct"], "0.005");
    }

    #[rstest]
    fn test_rpi_place_order_request_serialization() {
        let request = OKXPlaceOrderRequest {
            inst_id: "OMI-USD".to_string(),
            td_mode: OKXTradeMode::Cash,
            ccy: None,
            cl_ord_id: Some("ORPI001".to_string()),
            tag: Some("rpi-test".to_string()),
            side: OKXSide::Sell,
            pos_side: None,
            ord_type: OKXOrderType::Rpi,
            sz: "250000".to_string(),
            px: Some("0.0001600".to_string()),
            px_usd: None,
            px_vol: None,
            reduce_only: Some(false),
            tgt_ccy: None,
            attach_algo_ords: None,
            speed_bump: None,
            outcome: None,
            slippage_pct: None,
            rpi_taker_access: Some(true),
            rpi_px_round: Some(false),
        };

        let value = serde_json::to_value(request).unwrap();

        assert_eq!(
            value,
            serde_json::json!({
                "instId": "OMI-USD",
                "tdMode": "cash",
                "clOrdId": "ORPI001",
                "tag": "rpi-test",
                "side": "sell",
                "ordType": "rpi",
                "sz": "250000",
                "px": "0.0001600",
                "reduceOnly": false,
                "rpiTakerAccess": true,
                "rpiPxRound": false
            })
        );
    }

    #[rstest]
    fn test_rpi_amend_order_request_serialization() {
        let request = OKXAmendOrderRequest {
            inst_id: "OMI-USD".to_string(),
            ord_id: Some("2500000000000000001".to_string()),
            cl_ord_id: None,
            req_id: Some("RPI-AMEND-1".to_string()),
            new_sz: Some("275000".to_string()),
            new_px: Some("0.0001599".to_string()),
            rpi_taker_access: Some(false),
            rpi_px_round: Some(true),
        };

        let value = serde_json::to_value(request).unwrap();

        assert_eq!(
            value,
            serde_json::json!({
                "instId": "OMI-USD",
                "ordId": "2500000000000000001",
                "reqId": "RPI-AMEND-1",
                "newSz": "275000",
                "newPx": "0.0001599",
                "rpiTakerAccess": false,
                "rpiPxRound": true
            })
        );
    }

    #[rstest]
    fn test_rpi_place_order_response_parsing() {
        let response: OKXPlaceOrderResponse = serde_json::from_value(serde_json::json!({
            "ordId": "2500000000000000001",
            "clOrdId": "ORPI001",
            "tag": "rpi-test",
            "instId": "OMI-USD",
            "side": "sell",
            "ordType": "rpi",
            "sz": "250000",
            "state": "live",
            "px": "0.0001600",
            "avgPx": "",
            "sCode": "0",
            "sMsg": ""
        }))
        .unwrap();

        assert_eq!(response.ord_id, Some(Ustr::from("2500000000000000001")));
        assert_eq!(response.cl_ord_id, Some(Ustr::from("ORPI001")));
        assert_eq!(response.tag.as_deref(), Some("rpi-test"));
        assert_eq!(response.inst_id, Some(Ustr::from("OMI-USD")));
        assert_eq!(response.side, Some(OKXSide::Sell));
        assert_eq!(response.ord_type, Some(OKXOrderType::Rpi));
        assert_eq!(response.sz.as_deref(), Some("250000"));
        assert_eq!(response.state, Some(OKXOrderStatus::Live));
        assert_eq!(response.px.as_deref(), Some("0.0001600"));
        assert_eq!(response.avg_px.as_deref(), Some(""));
        assert_eq!(response.s_code.as_deref(), Some("0"));
        assert_eq!(response.s_msg.as_deref(), Some(""));
    }

    #[rstest]
    fn test_event_contract_models_deserialize() {
        let series: OKXEventContractSeries = serde_json::from_value(serde_json::json!({
            "seriesId": "BTC-ABOVE-DAILY",
            "freq": "daily",
            "title": "BTC above daily",
            "category": "1",
            "settlement": {
                "method": "cash",
                "closeEarly": false,
                "srcName": "OKX BTC/USD Index",
                "underlying": "BTC-USD"
            }
        }))
        .unwrap();
        let event: OKXEventContractEvent = serde_json::from_value(serde_json::json!({
            "seriesId": "BTC-ABOVE-DAILY",
            "eventId": "BTC-ABOVE-DAILY-260224-1600",
            "fixTime": "",
            "expTime": "1769697132335",
            "state": "live"
        }))
        .unwrap();
        let market: OKXEventContractMarket = serde_json::from_value(serde_json::json!({
            "seriesId": "BTC-ABOVE-DAILY",
            "eventId": "BTC-ABOVE-DAILY-260224-1600",
            "instId": "BTC-ABOVE-DAILY-260224-1600-65000",
            "listTime": "1769697132335",
            "fixTime": "",
            "expTime": "1769697132335",
            "state": "live",
            "disputed": false,
            "outcome": "0",
            "floorStrike": "120000",
            "settleValue": ""
        }))
        .unwrap();

        assert_eq!(series.series_id, "BTC-ABOVE-DAILY");
        assert_eq!(series.settlement.underlying, "BTC-USD");
        assert_eq!(event.fix_time, None);
        assert_eq!(event.exp_time, Some(1_769_697_132_335));
        assert_eq!(
            market.inst_id,
            Ustr::from("BTC-ABOVE-DAILY-260224-1600-65000")
        );
        assert_eq!(market.list_time, Some(1_769_697_132_335));
        assert_eq!(market.exp_time, Some(1_769_697_132_335));
        assert_eq!(market.outcome, "0");
    }

    #[rstest]
    fn test_event_contract_models_accept_missing_optional_fields() {
        let series: OKXEventContractSeries = serde_json::from_value(serde_json::json!({
            "seriesId": "BTC-ABOVE-DAILY"
        }))
        .unwrap();
        let event: OKXEventContractEvent = serde_json::from_value(serde_json::json!({
            "seriesId": "BTC-ABOVE-DAILY",
            "eventId": "BTC-ABOVE-DAILY-260224-1600",
            "fixTime": "",
            "expTime": "",
            "state": "live"
        }))
        .unwrap();
        let market: OKXEventContractMarket = serde_json::from_value(serde_json::json!({
            "seriesId": "BTC-ABOVE-DAILY",
            "eventId": "BTC-ABOVE-DAILY-260224-1600",
            "instId": "BTC-ABOVE-DAILY-260224-1600-65000",
            "listTime": "",
            "fixTime": "",
            "expTime": "",
            "state": "live",
            "disputed": false,
            "outcome": "0",
            "floorStrike": "120000",
            "settleValue": ""
        }))
        .unwrap();

        assert_eq!(series.freq, "");
        assert_eq!(series.settlement.underlying, "");
        assert_eq!(event.exp_time, None);
        assert_eq!(market.list_time, None);
        assert_eq!(market.exp_time, None);
    }

    #[rstest]
    fn test_place_order_request_serializes_event_contract_fields() {
        let request = OKXPlaceOrderRequest {
            inst_id: "BTC-ABOVE-DAILY-260224-1600-65000".to_string(),
            td_mode: OKXTradeMode::Cash,
            ccy: None,
            cl_ord_id: Some("event-1".to_string()),
            tag: None,
            side: OKXSide::Buy,
            pos_side: None,
            ord_type: OKXOrderType::Limit,
            sz: "10".to_string(),
            px: Some("0.42".to_string()),
            px_usd: None,
            px_vol: None,
            reduce_only: None,
            tgt_ccy: None,
            attach_algo_ords: None,
            speed_bump: Some("1".to_string()),
            outcome: Some("yes".to_string()),
            slippage_pct: None,
            rpi_taker_access: None,
            rpi_px_round: None,
        };

        let json: serde_json::Value = serde_json::to_value(&request).unwrap();

        assert_eq!(json["speedBump"], "1");
        assert_eq!(json["outcome"], "yes");
    }

    #[rstest]
    fn test_attach_algo_ord_request_serializes_trailing_fields() {
        let request = OKXAttachAlgoOrdRequest {
            attach_algo_cl_ord_id: Some("trail-1".to_string()),
            sl_trigger_px: None,
            sl_ord_px: None,
            sl_trigger_px_type: None,
            tp_trigger_px: None,
            tp_ord_px: None,
            tp_trigger_px_type: None,
            callback_ratio: Some("0.01".to_string()),
            callback_spread: None,
            active_px: Some("64000".to_string()),
            new_callback_ratio: Some("0.02".to_string()),
            new_callback_spread: Some("25".to_string()),
            new_active_px: Some("65000".to_string()),
        };

        let json: serde_json::Value = serde_json::to_value(&request).unwrap();

        assert_eq!(json["callbackRatio"], "0.01");
        assert_eq!(json["activePx"], "64000");
        assert_eq!(json["newCallbackRatio"], "0.02");
        assert_eq!(json["newCallbackSpread"], "25");
        assert_eq!(json["newActivePx"], "65000");
        assert!(json.get("callbackSpread").is_none());
    }

    #[rstest]
    fn test_place_order_response_deserializes_sub_code() {
        let response: OKXPlaceOrderResponse = serde_json::from_value(serde_json::json!({
            "ordId": "",
            "clOrdId": "event-1",
            "sCode": "51000",
            "sMsg": "Parameter error",
            "subCode": "51004"
        }))
        .unwrap();

        assert_eq!(response.cl_ord_id, Some(Ustr::from("event-1")));
        assert_eq!(response.s_code, Some("51000".to_string()));
        assert_eq!(response.sub_code, Some("51004".to_string()));
    }

    #[rstest]
    fn test_fee_rate_deserializes_settle() {
        let fee_rate: OKXFeeRate = serde_json::from_value(serde_json::json!({
            "level": "VIP1",
            "taker": "-0.0005",
            "maker": "-0.0002",
            "takerU": "-0.0005",
            "makerU": "-0.0002",
            "settle": "-0.001",
            "instType": "EVENTS",
            "category": "1",
            "ts": "1769697132335"
        }))
        .unwrap();

        assert_eq!(fee_rate.settle, "-0.001");
        assert_eq!(fee_rate.inst_type, OKXInstrumentType::Events);
    }

    #[rstest]
    fn test_rpi_maker_fee_rate_deserializes_decimal_and_legacy_alias() {
        let rpi: OKXFeeRate = serde_json::from_value(serde_json::json!({
            "level": "VIP1",
            "taker": "-0.0005",
            "maker": "-0.0002",
            "takerU": "-0.0005",
            "makerU": "-0.0002",
            "rpiMaker": "-0.00015",
            "instType": "SPOT",
            "category": "1",
            "ts": "1785406500000"
        }))
        .unwrap();
        let legacy: OKXFeeRate = serde_json::from_value(serde_json::json!({
            "level": "VIP1",
            "taker": "-0.0005",
            "maker": "-0.0002",
            "takerU": "-0.0005",
            "makerU": "-0.0002",
            "elpMaker": "-0.00016",
            "instType": "SPOT",
            "category": "1",
            "ts": "1785406500001"
        }))
        .unwrap();
        let not_applicable: OKXFeeRate = serde_json::from_value(serde_json::json!({
            "level": "VIP1",
            "taker": "-0.0005",
            "maker": "-0.0002",
            "takerU": "-0.0005",
            "makerU": "-0.0002",
            "rpiMaker": "",
            "instType": "OPTION",
            "category": "1",
            "ts": "1785406500002"
        }))
        .unwrap();

        assert_eq!(
            rpi.rpi_maker,
            Some(Decimal::from_str_exact("-0.00015").unwrap())
        );
        assert_eq!(
            legacy.rpi_maker,
            Some(Decimal::from_str_exact("-0.00016").unwrap())
        );
        assert_eq!(not_applicable.rpi_maker, None);
    }
}