nautilus_bybit/common/

enums.rs

// -------------------------------------------------------------------------------------------------
//  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.
// -------------------------------------------------------------------------------------------------

//! Enumerations that model Bybit string/int enums across HTTP and WebSocket payloads.

use std::fmt::Display;

use jiff::{Timestamp, civil::Date, tz::Offset};
use nautilus_model::enums::{AggressorSide, AssetClass, OrderSide, TriggerType};
use serde::{Deserialize, Serialize};
use serde_repr::{Deserialize_repr, Serialize_repr};
use strum::{AsRefStr, EnumIter, EnumString};

/// Unified margin account status values.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize_repr, Deserialize_repr)]
#[repr(i32)]
pub enum BybitUnifiedMarginStatus {
    /// Classic account.
    ClassicAccount = 1,
    /// Unified trading account 1.0.
    UnifiedTradingAccount10 = 3,
    /// Unified trading account 1.0 pro.
    UnifiedTradingAccount10Pro = 4,
    /// Unified trading account 2.0.
    UnifiedTradingAccount20 = 5,
    /// Unified trading account 2.0 pro.
    UnifiedTradingAccount20Pro = 6,
}

/// Margin mode used by Bybit when switching risk profiles.
#[derive(
    Clone,
    Copy,
    Debug,
    strum::Display,
    Eq,
    PartialEq,
    Hash,
    AsRefStr,
    EnumIter,
    EnumString,
    Serialize,
    Deserialize,
)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        eq,
        eq_int,
        rename_all = "SCREAMING_SNAKE_CASE",
        module = "nautilus_trader.adapters.bybit",
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitMarginMode {
    IsolatedMargin,
    RegularMargin,
    PortfolioMargin,
}

/// Position mode as returned by the v5 API.
#[derive(
    Clone,
    Copy,
    Debug,
    strum::Display,
    Eq,
    PartialEq,
    Hash,
    AsRefStr,
    EnumIter,
    EnumString,
    Serialize_repr,
    Deserialize_repr,
)]
#[repr(i32)]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        eq,
        eq_int,
        rename_all = "SCREAMING_SNAKE_CASE",
        module = "nautilus_trader.adapters.bybit",
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitPositionMode {
    /// Merged single position mode.
    MergedSingle = 0,
    /// Dual-side hedged position mode.
    BothSides = 3,
}

/// Position index values used for hedge mode payloads.
#[derive(
    Clone,
    Copy,
    Debug,
    strum::Display,
    Eq,
    PartialEq,
    Hash,
    AsRefStr,
    EnumIter,
    EnumString,
    Serialize_repr,
    Deserialize_repr,
)]
#[repr(i32)]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        eq,
        eq_int,
        rename_all = "SCREAMING_SNAKE_CASE",
        module = "nautilus_trader.adapters.bybit",
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitPositionIdx {
    /// One-way mode position identifier.
    OneWay = 0,
    /// Buy side of a hedge-mode position.
    BuyHedge = 1,
    /// Sell side of a hedge-mode position.
    SellHedge = 2,
}

/// Account type enumeration.
#[derive(
    Copy,
    Clone,
    Debug,
    strum::Display,
    PartialEq,
    Eq,
    Hash,
    AsRefStr,
    EnumIter,
    EnumString,
    Serialize,
    Deserialize,
)]
#[serde(rename_all = "UPPERCASE")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        eq,
        eq_int,
        rename_all = "SCREAMING_SNAKE_CASE",
        module = "nautilus_trader.adapters.bybit",
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitAccountType {
    Unified,
    Fund,
}

/// API key authentication type returned by `/v5/user/list-sub-apikeys`.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum BybitApiKeyType {
    /// HMAC-SHA256 signed keys (the default).
    Hmac = 1,
    /// RSA-signed keys.
    Rsa = 2,
}

/// Environments supported by the Bybit API stack.
#[derive(
    Copy,
    Clone,
    Debug,
    strum::Display,
    PartialEq,
    Eq,
    Hash,
    AsRefStr,
    EnumIter,
    EnumString,
    Serialize,
    Deserialize,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        eq,
        eq_int,
        rename_all = "SCREAMING_SNAKE_CASE",
        module = "nautilus_trader.adapters.bybit",
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitEnvironment {
    /// Live trading environment.
    Mainnet,
    /// Demo (paper trading) environment.
    Demo,
    /// Testnet environment for spot/derivatives.
    Testnet,
}

/// Product categories supported by the v5 API.
#[derive(
    Copy,
    Clone,
    Debug,
    strum::Display,
    Default,
    PartialEq,
    Eq,
    Hash,
    AsRefStr,
    EnumIter,
    EnumString,
    Serialize,
    Deserialize,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        eq,
        eq_int,
        rename_all = "SCREAMING_SNAKE_CASE",
        module = "nautilus_trader.adapters.bybit",
        from_py_object
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitProductType {
    #[default]
    Spot,
    Linear,
    Inverse,
    Option,
}

/// Spot margin trading enablement states.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitMarginTrading {
    #[serde(rename = "none")]
    None,
    #[serde(rename = "utaOnly")]
    UtaOnly,
    #[serde(rename = "both")]
    Both,
    #[serde(rename = "normalSpotOnly")]
    NormalSpotOnly,
    #[serde(other)]
    Other,
}

/// Innovation market flag for spot instruments.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitInnovationFlag {
    #[serde(rename = "0")]
    Standard,
    #[serde(rename = "1")]
    Innovation,
    #[serde(other)]
    Other,
}

/// Instrument lifecycle status values.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum BybitInstrumentStatus {
    PreLaunch,
    PendingOpen,
    Trading,
    Delivering,
    Closed,
    #[serde(other)]
    Other,
}

impl BybitProductType {
    /// Returns the canonical lowercase identifier used for REST/WS routes.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Spot => "spot",
            Self::Linear => "linear",
            Self::Inverse => "inverse",
            Self::Option => "option",
        }
    }

    /// Returns the uppercase suffix used in instrument identifiers (e.g. `-LINEAR`).
    #[must_use]
    pub const fn suffix(self) -> &'static str {
        match self {
            Self::Spot => "-SPOT",
            Self::Linear => "-LINEAR",
            Self::Inverse => "-INVERSE",
            Self::Option => "-OPTION",
        }
    }

    /// Returns the product type identified by the suffix in the symbol string.
    #[must_use]
    pub fn from_suffix(symbol: &str) -> Option<Self> {
        if symbol.ends_with("-SPOT") {
            Some(Self::Spot)
        } else if symbol.ends_with("-LINEAR") {
            Some(Self::Linear)
        } else if symbol.ends_with("-INVERSE") {
            Some(Self::Inverse)
        } else if symbol.ends_with("-OPTION") {
            Some(Self::Option)
        } else {
            None
        }
    }

    /// Returns `true` if the product is a spot instrument.
    #[must_use]
    pub fn is_spot(self) -> bool {
        matches!(self, Self::Spot)
    }

    /// Returns `true` if the product is a linear contract.
    #[must_use]
    pub fn is_linear(self) -> bool {
        matches!(self, Self::Linear)
    }

    /// Returns `true` if the product is an inverse contract.
    #[must_use]
    pub fn is_inverse(self) -> bool {
        matches!(self, Self::Inverse)
    }

    /// Returns `true` if the product is an option contract.
    #[must_use]
    pub fn is_option(self) -> bool {
        matches!(self, Self::Option)
    }
}

/// Contract type enumeration for linear and inverse derivatives.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum BybitContractType {
    LinearPerpetual,
    LinearFutures,
    InversePerpetual,
    InverseFutures,
}

/// Option flavor values.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum BybitOptionType {
    Call,
    Put,
}

/// Symbol type values for spot/linear/inverse instrument info responses.
///
/// New values may be added by the venue; unknown strings fall back to `Other` so deserialization
/// remains forward-compatible.
///
/// # References
/// - <https://bybit-exchange.github.io/docs/v5/enum#symboltype>
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum BybitSymbolType {
    /// Innovation-zone derivatives.
    Innovation,
    /// Adventure-zone spot pairs.
    Adventure,
    /// Tokenized equities (spot xstocks).
    Xstocks,
    /// Commodity instruments.
    Commodity,
    /// Tokenized stock derivatives.
    Stock,
    /// Foreign exchange instruments.
    Forex,
    /// Exchange-traded fund derivatives.
    #[serde(rename = "ETF")]
    Etf,
    /// Tokenized equities (spot mstocks).
    Mstocks,
    /// Forward-compatible fallback for any value the venue adds later.
    #[serde(other)]
    Other,
}

impl BybitSymbolType {
    /// Returns the exact recognized value used by Bybit, or `None` for an unknown value.
    #[must_use]
    pub(crate) const fn as_str(self) -> Option<&'static str> {
        match self {
            Self::Innovation => Some("innovation"),
            Self::Adventure => Some("adventure"),
            Self::Xstocks => Some("xstocks"),
            Self::Commodity => Some("commodity"),
            Self::Stock => Some("stock"),
            Self::Forex => Some("forex"),
            Self::Etf => Some("ETF"),
            Self::Mstocks => Some("mstocks"),
            Self::Other => None,
        }
    }
}

impl From<BybitSymbolType> for AssetClass {
    fn from(symbol_type: BybitSymbolType) -> Self {
        match symbol_type {
            BybitSymbolType::Innovation | BybitSymbolType::Adventure => Self::Cryptocurrency,
            BybitSymbolType::Stock
            | BybitSymbolType::Etf
            | BybitSymbolType::Xstocks
            | BybitSymbolType::Mstocks => Self::Equity,
            BybitSymbolType::Commodity => Self::Commodity,
            BybitSymbolType::Forex => Self::FX,
            BybitSymbolType::Other => Self::Alternative,
        }
    }
}

/// Position side as represented in REST/WebSocket payloads.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitPositionSide {
    #[serde(rename = "")]
    Flat,
    #[serde(rename = "Buy")]
    Buy,
    #[serde(rename = "Sell")]
    Sell,
}

/// WebSocket order request operations.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitWsOrderRequestOp {
    #[serde(rename = "order.create")]
    Create,
    #[serde(rename = "order.amend")]
    Amend,
    #[serde(rename = "order.cancel")]
    Cancel,
    #[serde(rename = "order.create-batch")]
    CreateBatch,
    #[serde(rename = "order.amend-batch")]
    AmendBatch,
    #[serde(rename = "order.cancel-batch")]
    CancelBatch,
}

/// Available kline intervals.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitKlineInterval {
    #[serde(rename = "1")]
    Minute1,
    #[serde(rename = "3")]
    Minute3,
    #[serde(rename = "5")]
    Minute5,
    #[serde(rename = "15")]
    Minute15,
    #[serde(rename = "30")]
    Minute30,
    #[serde(rename = "60")]
    Hour1,
    #[serde(rename = "120")]
    Hour2,
    #[serde(rename = "240")]
    Hour4,
    #[serde(rename = "360")]
    Hour6,
    #[serde(rename = "720")]
    Hour12,
    #[serde(rename = "D")]
    Day1,
    #[serde(rename = "W")]
    Week1,
    #[serde(rename = "M")]
    Month1,
}

impl BybitKlineInterval {
    /// Returns the end time in milliseconds for a bar that starts at `start_ms`.
    ///
    /// For most intervals this is simply `start_ms + duration`. For monthly bars,
    /// this calculates the actual first millisecond of the next month to handle
    /// variable month lengths (28-31 days).
    #[must_use]
    pub fn bar_end_time_ms(&self, start_ms: i64) -> i64 {
        match self {
            Self::Month1 => {
                let start_dt = Offset::UTC.to_datetime(
                    Timestamp::from_millisecond(start_ms).unwrap_or(Timestamp::UNIX_EPOCH),
                );
                let (year, month) = if start_dt.month() == 12 {
                    (start_dt.year() + 1, 1)
                } else {
                    (start_dt.year(), start_dt.month() + 1)
                };
                Date::new(year, month, 1)
                    .and_then(|date| Offset::UTC.to_timestamp(date.at(0, 0, 0, 0)))
                    .map_or(start_ms + 2_678_400_000, Timestamp::as_millisecond)
            }
            _ => start_ms + self.duration_ms(),
        }
    }

    /// Returns the fixed duration of this interval in milliseconds.
    ///
    /// Note: For monthly bars, use [`Self::bar_end_time_ms`] instead as months have
    /// variable lengths (28-31 days).
    #[must_use]
    pub const fn duration_ms(&self) -> i64 {
        match self {
            Self::Minute1 => 60_000,
            Self::Minute3 => 180_000,
            Self::Minute5 => 300_000,
            Self::Minute15 => 900_000,
            Self::Minute30 => 1_800_000,
            Self::Hour1 => 3_600_000,
            Self::Hour2 => 7_200_000,
            Self::Hour4 => 14_400_000,
            Self::Hour6 => 21_600_000,
            Self::Hour12 => 43_200_000,
            Self::Day1 => 86_400_000,
            Self::Week1 => 604_800_000,
            Self::Month1 => 2_678_400_000, // 31 days - use bar_end_time_ms() for accurate calculation
        }
    }
}

impl Display for BybitKlineInterval {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s = match self {
            Self::Minute1 => "1",
            Self::Minute3 => "3",
            Self::Minute5 => "5",
            Self::Minute15 => "15",
            Self::Minute30 => "30",
            Self::Hour1 => "60",
            Self::Hour2 => "120",
            Self::Hour4 => "240",
            Self::Hour6 => "360",
            Self::Hour12 => "720",
            Self::Day1 => "D",
            Self::Week1 => "W",
            Self::Month1 => "M",
        };
        write!(f, "{s}")
    }
}

/// Order status values returned by Bybit.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitOrderStatus {
    #[serde(rename = "Created")]
    Created,
    #[serde(rename = "New")]
    New,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "PartiallyFilled")]
    PartiallyFilled,
    #[serde(rename = "PartiallyFilledCanceled")]
    PartiallyFilledCanceled,
    #[serde(rename = "Filled")]
    Filled,
    #[serde(rename = "Cancelled")]
    Canceled,
    #[serde(rename = "Untriggered")]
    Untriggered,
    #[serde(rename = "Triggered")]
    Triggered,
    #[serde(rename = "Deactivated")]
    Deactivated,
}

/// Order side enumeration.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitOrderSide {
    #[serde(rename = "")]
    Unknown,
    #[serde(rename = "Buy")]
    Buy,
    #[serde(rename = "Sell")]
    Sell,
}

impl From<BybitOrderSide> for AggressorSide {
    fn from(value: BybitOrderSide) -> Self {
        match value {
            BybitOrderSide::Buy => Self::Buy,
            BybitOrderSide::Sell => Self::Sell,
            BybitOrderSide::Unknown => Self::NoAggressor,
        }
    }
}

impl From<BybitOrderSide> for Option<OrderSide> {
    fn from(value: BybitOrderSide) -> Self {
        match value {
            BybitOrderSide::Buy => Some(OrderSide::Buy),
            BybitOrderSide::Sell => Some(OrderSide::Sell),
            BybitOrderSide::Unknown => None,
        }
    }
}

impl TryFrom<BybitOrderSide> for OrderSide {
    type Error = anyhow::Error;

    fn try_from(value: BybitOrderSide) -> Result<Self, Self::Error> {
        match value {
            BybitOrderSide::Buy => Ok(Self::Buy),
            BybitOrderSide::Sell => Ok(Self::Sell),
            BybitOrderSide::Unknown => anyhow::bail!("Unspecified Bybit order side"),
        }
    }
}

impl From<OrderSide> for BybitOrderSide {
    fn from(value: OrderSide) -> Self {
        match value {
            OrderSide::Buy => Self::Buy,
            OrderSide::Sell => Self::Sell,
        }
    }
}

impl From<BybitTriggerType> for TriggerType {
    fn from(value: BybitTriggerType) -> Self {
        match value {
            BybitTriggerType::None => Self::Default,
            BybitTriggerType::LastPrice => Self::LastPrice,
            BybitTriggerType::IndexPrice => Self::IndexPrice,
            BybitTriggerType::MarkPrice => Self::MarkPrice,
        }
    }
}

impl From<TriggerType> for BybitTriggerType {
    fn from(value: TriggerType) -> Self {
        match value {
            TriggerType::Default | TriggerType::LastPrice => Self::LastPrice,
            TriggerType::IndexPrice => Self::IndexPrice,
            TriggerType::MarkPrice => Self::MarkPrice,
            _ => Self::LastPrice,
        }
    }
}

/// Resolves an optional Nautilus trigger type to a Bybit trigger type,
/// defaulting to `LastPrice` when absent.
pub fn resolve_trigger_type(trigger_type: Option<TriggerType>) -> BybitTriggerType {
    trigger_type.map_or(BybitTriggerType::LastPrice, BybitTriggerType::from)
}

/// Order cancel reason values as returned by Bybit.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitCancelType {
    CancelByUser,
    CancelByReduceOnly,
    CancelByPrepareLiq,
    CancelAllBeforeLiq,
    CancelByPrepareAdl,
    CancelAllBeforeAdl,
    CancelByPrepareLackOfMargin,
    CancelByPrepareOrderFilter,
    CancelByPrepareOrderMarginCheckFailed,
    CancelByPrepareOrderCommission,
    CancelByPrepareOrderRms,
    CancelByPrepareOrderOther,
    CancelByRiskLimit,
    CancelOnDisconnect,
    CancelByStopOrdersExceeded,
    CancelByPzMarketClose,
    CancelByMarginCheckFailed,
    CancelByPzTakeover,
    CancelByAdmin,
    CancelBySettle,
    CancelByTpSlTsClear,
    CancelByAmendNotModified,
    CancelByPzCancel,
    CancelBySmp,
    #[serde(rename = "CancelByDCP")]
    CancelByDcp,
    CancelByRebalance,
    #[serde(rename = "CancelByOCOTpCanceledBySlTriggered")]
    CancelByOcoTpCanceledBySlTriggered,
    #[serde(rename = "CancelByOCOSlCanceledByTpTriggered")]
    CancelByOcoSlCanceledByTpTriggered,
    CancelByCannotAffordOrderCost,
    CancelByPmTrialMmOverEquity,
    CancelByAccountBlocking,
    CancelByDelivery,
    CancelByMmpTriggered,
    CancelByCrossSelfMuch,
    CancelByCrossReachMaxTradeNum,
    CancelByCrossSelfMatch,
    CancelBySelfMatchPrevention,
    #[serde(other)]
    Other,
}

/// Order creation origin values.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum BybitCreateType {
    CreateByUser,
    CreateByFutureSpread,
    CreateByAdminClosing,
    CreateBySettle,
    CreateByClosing,
    CreateByTakeProfit,
    CreateByStopLoss,
    CreateByTrailingStop,
    CreateByTrailingProfit,
    CreateByStopOrder,
    CreateByPartialTakeProfit,
    CreateByPartialStopLoss,
    CreateByAdl,
    #[serde(rename = "CreateByAdl_PassThrough")]
    CreateByAdlPassThrough,
    CreateByLiq,
    CreateByLiquidate,
    CreateByTakeover,
    #[serde(rename = "CreateByTakeOver_PassThrough")]
    CreateByTakeOverPassThrough,
    #[serde(rename = "CreateByBlock_PassThrough")]
    CreateByBlockPassThrough,
    #[serde(rename = "CreateByBlockTradeMovePosition_PassThrough")]
    CreateByBlockTradeMovePositionPassThrough,
    CreateByChaseOrder,
    #[serde(rename = "CreateByFGridBot")]
    CreateByFGridBot,
    #[serde(rename = "CloseByFGridBot")]
    CloseByFGridBot,
    #[serde(rename = "CreateByTWAP")]
    CreateByTwap,
    CreateByMartingaleBot,
    CloseByMartingaleBot,
    #[serde(rename = "CreateByIceBerg")]
    CreateByIceBerg,
    CreateByBboOrder,
    #[serde(rename = "CreateByTVSignal")]
    CreateByTvSignal,
    CreateByMmRateClose,
    CreateByArbitrage,
    CreateByDdh,
    CreateByTpsl,
    #[serde(other)]
    Other,
}

/// BBO side type values for Bybit order placement.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum BybitBboSideType {
    Queue,
    Counterparty,
}

/// Venue order type enumeration.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitOrderType {
    #[serde(rename = "Market")]
    Market,
    #[serde(rename = "Limit")]
    Limit,
    #[serde(rename = "UNKNOWN")]
    Unknown,
}

/// Stop order type classification.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitStopOrderType {
    #[serde(rename = "")]
    None,
    #[serde(rename = "UNKNOWN")]
    Unknown,
    #[serde(rename = "TakeProfit")]
    TakeProfit,
    #[serde(rename = "StopLoss")]
    StopLoss,
    #[serde(rename = "TrailingStop")]
    TrailingStop,
    #[serde(rename = "Stop")]
    Stop,
    #[serde(rename = "PartialTakeProfit")]
    PartialTakeProfit,
    #[serde(rename = "PartialStopLoss")]
    PartialStopLoss,
    #[serde(rename = "tpslOrder")]
    TpslOrder,
    #[serde(rename = "OcoOrder")]
    OcoOrder,
    #[serde(rename = "MmRateClose")]
    MmRateClose,
    #[serde(rename = "BidirectionalTpslOrder")]
    BidirectionalTpslOrder,
}

/// Trigger type configuration.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitTriggerType {
    #[serde(rename = "")]
    None,
    #[serde(rename = "LastPrice")]
    LastPrice,
    #[serde(rename = "IndexPrice")]
    IndexPrice,
    #[serde(rename = "MarkPrice")]
    MarkPrice,
}

/// Trigger direction integers used by the API.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize_repr, Deserialize_repr)]
#[repr(i32)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitTriggerDirection {
    None = 0,
    RisesTo = 1,
    FallsTo = 2,
}

/// Take-profit/stop-loss mode for derivatives orders.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitTpSlMode {
    Full,
    Partial,
    #[serde(other)]
    Unknown,
}

/// Time-in-force enumeration.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitTimeInForce {
    #[serde(rename = "GTC")]
    Gtc,
    #[serde(rename = "IOC")]
    Ioc,
    #[serde(rename = "FOK")]
    Fok,
    #[serde(rename = "PostOnly")]
    PostOnly,
    #[serde(rename = "RPI")]
    Rpi,
}

/// Execution type values used in execution reports.
///
/// Reference: <https://bybit-exchange.github.io/docs/v5/enum#exectype>.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitExecType {
    #[serde(rename = "Trade")]
    Trade,
    #[serde(rename = "AdlTrade")]
    AdlTrade,
    #[serde(rename = "Funding")]
    Funding,
    #[serde(rename = "BustTrade")]
    BustTrade,
    #[serde(rename = "Delivery")]
    Delivery,
    #[serde(rename = "Settle")]
    Settle,
    #[serde(rename = "BlockTrade")]
    BlockTrade,
    #[serde(rename = "MovePosition")]
    MovePosition,
    #[serde(rename = "FutureSpread")]
    FutureSpread,
    /// Retained for execution history recorded while the venue issued this type
    /// (2026-07-23 to 2026-08-20), before its replacement by the split settlement
    /// and dividend types.
    #[serde(rename = "CorporateAction")]
    CorporateAction,
    #[serde(rename = "ForwardSplitSettle")]
    ForwardSplitSettle,
    #[serde(rename = "ReverseSplitSettle")]
    ReverseSplitSettle,
    #[serde(rename = "Dividend")]
    Dividend,
    #[serde(other)]
    #[serde(rename = "UNKNOWN")]
    Unknown,
}

impl BybitExecType {
    /// Returns `true` if this execution was generated by the venue rather than the user.
    ///
    /// This covers auto-deleveraging (`AdlTrade`), liquidation takeovers (`BustTrade`),
    /// scheduled deliveries (`Delivery`), settlement (`Settle`), and corporate actions
    /// (`CorporateAction`, `ForwardSplitSettle`, `ReverseSplitSettle`, `Dividend`).
    #[must_use]
    pub const fn is_exchange_generated(&self) -> bool {
        matches!(
            self,
            Self::AdlTrade
                | Self::BustTrade
                | Self::Delivery
                | Self::Settle
                | Self::CorporateAction
                | Self::ForwardSplitSettle
                | Self::ReverseSplitSettle
                | Self::Dividend
        )
    }
}

/// Transaction types for wallet funding records.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitTransactionType {
    #[serde(rename = "TRANSFER_IN")]
    TransferIn,
    #[serde(rename = "TRANSFER_OUT")]
    TransferOut,
    #[serde(rename = "TRADE")]
    Trade,
    #[serde(rename = "SETTLEMENT")]
    Settlement,
    #[serde(rename = "DELIVERY")]
    Delivery,
    #[serde(rename = "LIQUIDATION")]
    Liquidation,
    #[serde(rename = "AIRDRP")]
    Airdrop,
    #[serde(rename = "ADL")]
    Adl,
    #[serde(rename = "DIVIDEND_SETTLEMENT")]
    DividendSettlement,
    #[serde(rename = "FORWARD_SPLIT_SETTLE")]
    ForwardSplitSettle,
    #[serde(rename = "REVERSE_SPLIT_SETTLE")]
    ReverseSplitSettle,
    #[serde(other)]
    Other,
}

/// Endpoint classifications used by the Bybit API.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum BybitEndpointType {
    None,
    Asset,
    Market,
    Account,
    Trade,
    Position,
    User,
}

/// Filter for open orders query.
///
/// Used with `GET /v5/order/realtime` to filter order status.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Hash, Serialize_repr, Deserialize_repr)]
#[repr(i32)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitOpenOnly {
    /// Query open status orders only (New, PartiallyFilled).
    #[default]
    OpenOnly = 0,
    /// Query up to 500 recent closed orders (cancelled, rejected, filled).
    ClosedRecent = 1,
}

/// Order filter for querying specific order types.
///
/// Used with `GET /v5/order/realtime` to filter by order category.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.adapters.bybit", eq, eq_int, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitOrderFilter {
    /// Active orders (default).
    #[default]
    Order,
    /// Conditional orders (futures and spot).
    StopOrder,
    /// Spot take-profit/stop-loss orders.
    #[serde(rename = "tpslOrder")]
    TpslOrder,
    /// Spot one-cancels-other orders.
    OcoOrder,
    /// Spot bidirectional TP/SL orders.
    BidirectionalTpslOrder,
}

/// Margin actions for spot margin trading operations.
#[derive(
    Clone,
    Copy,
    Debug,
    strum::Display,
    Eq,
    PartialEq,
    Hash,
    AsRefStr,
    EnumIter,
    EnumString,
    Serialize,
    Deserialize,
)]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        eq,
        eq_int,
        hash,
        frozen,
        rename_all = "SCREAMING_SNAKE_CASE",
        module = "nautilus_trader.adapters.bybit",
        from_py_object,
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.bybit")
)]
pub enum BybitMarginAction {
    /// Borrow funds for margin trading.
    Borrow,
    /// Repay borrowed funds.
    Repay,
    /// Query current borrowed amount.
    GetBorrowAmount,
}

/// Result status returned by Bybit repayment endpoints.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, strum::Display, Serialize, Deserialize)]
pub enum BybitRepayStatus {
    /// The repayment is processing.
    #[serde(rename = "P")]
    #[strum(serialize = "P")]
    Processing,
    /// The repayment succeeded.
    #[serde(rename = "SU")]
    #[strum(serialize = "SU")]
    Success,
    /// The repayment failed.
    #[serde(rename = "FA")]
    #[strum(serialize = "FA")]
    Failed,
}

/// Position status enumeration.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum BybitPositionStatus {
    Normal,
    Liq,
    Adl,
    Settle,
    Delivering,
    #[serde(other)]
    Other,
}

/// Market unit for spot market orders.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitMarketUnit {
    #[serde(rename = "baseCoin")]
    BaseCoin,
    #[serde(rename = "quoteCoin")]
    QuoteCoin,
}

/// Self-match prevention type reported on an order or execution.
///
/// `Other` is a catch-all for values Bybit adds after this enum was written. Requests use
/// [`BybitOrderSmpType`], which has no catch-all, so an unknown value cannot reach the venue.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub enum BybitSmpType {
    None,
    CancelMaker,
    CancelTaker,
    CancelBoth,
    #[serde(other)]
    Other,
}

/// Self-match prevention type accepted on an order request.
///
/// Mirrors [`BybitSmpType`] without its inbound catch-all, so every value this type can hold is one
/// Bybit accepts on an order.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, AsRefStr, Serialize, Deserialize)]
pub enum BybitOrderSmpType {
    None,
    CancelMaker,
    CancelTaker,
    CancelBoth,
}

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

    use super::*;

    #[rstest]
    #[case::minute1(BybitKlineInterval::Minute1, 60_000)]
    #[case::minute3(BybitKlineInterval::Minute3, 180_000)]
    #[case::minute5(BybitKlineInterval::Minute5, 300_000)]
    #[case::minute15(BybitKlineInterval::Minute15, 900_000)]
    #[case::minute30(BybitKlineInterval::Minute30, 1_800_000)]
    #[case::hour1(BybitKlineInterval::Hour1, 3_600_000)]
    #[case::hour2(BybitKlineInterval::Hour2, 7_200_000)]
    #[case::hour4(BybitKlineInterval::Hour4, 14_400_000)]
    #[case::hour6(BybitKlineInterval::Hour6, 21_600_000)]
    #[case::hour12(BybitKlineInterval::Hour12, 43_200_000)]
    #[case::day1(BybitKlineInterval::Day1, 86_400_000)]
    #[case::week1(BybitKlineInterval::Week1, 604_800_000)]
    #[case::month1(BybitKlineInterval::Month1, 2_678_400_000)]
    fn test_kline_interval_duration_ms(
        #[case] interval: BybitKlineInterval,
        #[case] expected_ms: i64,
    ) {
        assert_eq!(interval.duration_ms(), expected_ms);
    }

    #[rstest]
    fn test_bar_end_time_ms_non_monthly_adds_duration() {
        let interval = BybitKlineInterval::Minute1;
        let start_ms = 1704067200000i64;
        assert_eq!(interval.bar_end_time_ms(start_ms), start_ms + 60_000);
    }

    #[rstest]
    #[case::jan_31_days(1704067200000i64, 1706745600000i64)]
    #[case::feb_leap_year_29_days(1706745600000i64, 1709251200000i64)]
    #[case::apr_30_days(1711929600000i64, 1714521600000i64)]
    #[case::dec_to_next_year(1733011200000i64, 1735689600000i64)]
    fn test_bar_end_time_ms_monthly_variable_lengths(
        #[case] start_ms: i64,
        #[case] expected_end_ms: i64,
    ) {
        let interval = BybitKlineInterval::Month1;
        assert_eq!(interval.bar_end_time_ms(start_ms), expected_end_ms);
    }

    #[rstest]
    #[case(BybitSymbolType::Innovation, "innovation")]
    #[case(BybitSymbolType::Adventure, "adventure")]
    #[case(BybitSymbolType::Xstocks, "xstocks")]
    #[case(BybitSymbolType::Commodity, "commodity")]
    #[case(BybitSymbolType::Stock, "stock")]
    #[case(BybitSymbolType::Forex, "forex")]
    #[case(BybitSymbolType::Etf, "ETF")]
    #[case(BybitSymbolType::Mstocks, "mstocks")]
    fn test_symbol_type_round_trip(#[case] symbol_type: BybitSymbolType, #[case] wire_value: &str) {
        let value = serde_json::Value::String(wire_value.to_string());

        assert_eq!(
            serde_json::from_value::<BybitSymbolType>(value.clone()).unwrap(),
            symbol_type
        );
        assert_eq!(serde_json::to_value(symbol_type).unwrap(), value);
        assert_eq!(symbol_type.as_str(), Some(wire_value));
    }

    #[rstest]
    fn test_unknown_symbol_type_has_no_wire_value() {
        assert_eq!(BybitSymbolType::Other.as_str(), None);
    }

    #[rstest]
    #[case(BybitSymbolType::Innovation, AssetClass::Cryptocurrency)]
    #[case(BybitSymbolType::Adventure, AssetClass::Cryptocurrency)]
    #[case(BybitSymbolType::Stock, AssetClass::Equity)]
    #[case(BybitSymbolType::Etf, AssetClass::Equity)]
    #[case(BybitSymbolType::Xstocks, AssetClass::Equity)]
    #[case(BybitSymbolType::Mstocks, AssetClass::Equity)]
    #[case(BybitSymbolType::Commodity, AssetClass::Commodity)]
    #[case(BybitSymbolType::Forex, AssetClass::FX)]
    #[case(BybitSymbolType::Other, AssetClass::Alternative)]
    fn test_symbol_type_to_asset_class(
        #[case] symbol_type: BybitSymbolType,
        #[case] expected: AssetClass,
    ) {
        assert_eq!(AssetClass::from(symbol_type), expected);
    }

    #[rstest]
    #[case(BybitExecType::Trade, false)]
    #[case(BybitExecType::AdlTrade, true)]
    #[case(BybitExecType::BustTrade, true)]
    #[case(BybitExecType::Delivery, true)]
    #[case(BybitExecType::Settle, true)]
    #[case(BybitExecType::Funding, false)]
    #[case(BybitExecType::BlockTrade, false)]
    #[case(BybitExecType::MovePosition, false)]
    #[case(BybitExecType::FutureSpread, false)]
    #[case(BybitExecType::CorporateAction, true)]
    #[case(BybitExecType::ForwardSplitSettle, true)]
    #[case(BybitExecType::ReverseSplitSettle, true)]
    #[case(BybitExecType::Dividend, true)]
    #[case(BybitExecType::Unknown, false)]
    fn test_exec_type_is_exchange_generated(
        #[case] exec_type: BybitExecType,
        #[case] expected: bool,
    ) {
        assert_eq!(exec_type.is_exchange_generated(), expected);
    }

    #[rstest]
    #[case(BybitExecType::Trade, "Trade")]
    #[case(BybitExecType::AdlTrade, "AdlTrade")]
    #[case(BybitExecType::Funding, "Funding")]
    #[case(BybitExecType::BustTrade, "BustTrade")]
    #[case(BybitExecType::Delivery, "Delivery")]
    #[case(BybitExecType::Settle, "Settle")]
    #[case(BybitExecType::BlockTrade, "BlockTrade")]
    #[case(BybitExecType::MovePosition, "MovePosition")]
    #[case(BybitExecType::FutureSpread, "FutureSpread")]
    #[case(BybitExecType::CorporateAction, "CorporateAction")]
    #[case(BybitExecType::ForwardSplitSettle, "ForwardSplitSettle")]
    #[case(BybitExecType::ReverseSplitSettle, "ReverseSplitSettle")]
    #[case(BybitExecType::Dividend, "Dividend")]
    #[case(BybitExecType::Unknown, "UNKNOWN")]
    fn test_exec_type_round_trip(#[case] exec_type: BybitExecType, #[case] wire_value: &str) {
        let value = serde_json::Value::String(wire_value.to_string());

        assert_eq!(
            serde_json::from_value::<BybitExecType>(value.clone()).unwrap(),
            exec_type
        );
        assert_eq!(serde_json::to_value(exec_type).unwrap(), value);
    }

    #[rstest]
    fn test_exec_type_unrecognized_value_deserializes_to_unknown() {
        let value = serde_json::Value::String("StockMerger".to_string());

        assert_eq!(
            serde_json::from_value::<BybitExecType>(value).unwrap(),
            BybitExecType::Unknown
        );
    }

    #[rstest]
    #[case(BybitAccountType::Unified, "UNIFIED")]
    #[case(BybitAccountType::Fund, "FUND")]
    fn test_account_type_round_trip(
        #[case] account_type: BybitAccountType,
        #[case] wire_value: &str,
    ) {
        let value = serde_json::Value::String(wire_value.to_string());

        assert_eq!(
            serde_json::from_value::<BybitAccountType>(value.clone()).unwrap(),
            account_type
        );
        assert_eq!(serde_json::to_value(account_type).unwrap(), value);
    }

    #[rstest]
    #[case(BybitTimeInForce::Gtc, "GTC")]
    #[case(BybitTimeInForce::Ioc, "IOC")]
    #[case(BybitTimeInForce::Fok, "FOK")]
    #[case(BybitTimeInForce::PostOnly, "PostOnly")]
    #[case(BybitTimeInForce::Rpi, "RPI")]
    fn test_time_in_force_round_trip(#[case] tif: BybitTimeInForce, #[case] wire_value: &str) {
        let value = serde_json::Value::String(wire_value.to_string());

        assert_eq!(
            serde_json::from_value::<BybitTimeInForce>(value.clone()).unwrap(),
            tif
        );
        assert_eq!(serde_json::to_value(tif).unwrap(), value);
    }

    #[rstest]
    #[case("CreateByAdl_PassThrough", BybitCreateType::CreateByAdlPassThrough)]
    #[case("CreateByLiq", BybitCreateType::CreateByLiq)]
    #[case(
        "CreateByTakeOver_PassThrough",
        BybitCreateType::CreateByTakeOverPassThrough
    )]
    #[case("CreateByTWAP", BybitCreateType::CreateByTwap)]
    #[case("CreateByFutureSpread", BybitCreateType::CreateByFutureSpread)]
    fn test_create_type_venue_wire_values(
        #[case] wire_value: &str,
        #[case] expected: BybitCreateType,
    ) {
        let value = serde_json::Value::String(wire_value.to_string());

        assert_eq!(
            serde_json::from_value::<BybitCreateType>(value.clone()).unwrap(),
            expected
        );
        assert_eq!(serde_json::to_value(expected).unwrap(), value);
    }

    #[rstest]
    #[case("CancelBySettle", BybitCancelType::CancelBySettle)]
    #[case("CancelBySmp", BybitCancelType::CancelBySmp)]
    #[case("CancelByDCP", BybitCancelType::CancelByDcp)]
    #[case("CancelAllBeforeLiq", BybitCancelType::CancelAllBeforeLiq)]
    #[case(
        "CancelByOCOTpCanceledBySlTriggered",
        BybitCancelType::CancelByOcoTpCanceledBySlTriggered
    )]
    fn test_cancel_type_venue_wire_values(
        #[case] wire_value: &str,
        #[case] expected: BybitCancelType,
    ) {
        let value = serde_json::Value::String(wire_value.to_string());

        assert_eq!(
            serde_json::from_value::<BybitCancelType>(value.clone()).unwrap(),
            expected
        );
        assert_eq!(serde_json::to_value(expected).unwrap(), value);
    }

    #[rstest]
    fn test_pending_open_instrument_status_round_trip() {
        let value = serde_json::Value::String("PendingOpen".to_string());

        assert_eq!(
            serde_json::from_value::<BybitInstrumentStatus>(value.clone()).unwrap(),
            BybitInstrumentStatus::PendingOpen
        );
        assert_eq!(
            serde_json::to_value(BybitInstrumentStatus::PendingOpen).unwrap(),
            value
        );
    }

    #[rstest]
    fn test_normal_spot_only_margin_trading_round_trip() {
        let value = serde_json::Value::String("normalSpotOnly".to_string());

        assert_eq!(
            serde_json::from_value::<BybitMarginTrading>(value.clone()).unwrap(),
            BybitMarginTrading::NormalSpotOnly
        );
        assert_eq!(
            serde_json::to_value(BybitMarginTrading::NormalSpotOnly).unwrap(),
            value
        );
    }

    #[rstest]
    #[case(BybitPositionStatus::Liq, "Liq")]
    #[case(BybitPositionStatus::Adl, "Adl")]
    fn test_position_status_liq_adl_round_trip(
        #[case] status: BybitPositionStatus,
        #[case] wire_value: &str,
    ) {
        let value = serde_json::Value::String(wire_value.to_string());

        assert_eq!(
            serde_json::from_value::<BybitPositionStatus>(value.clone()).unwrap(),
            status
        );
        assert_eq!(serde_json::to_value(status).unwrap(), value);
    }
}