ccxt-pro 4.5.84

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

#![allow(unused, non_snake_case, clippy::all)]
use crate::Value;
use crate::get_value;
use crate::runtime::*;
// Base methods are now trait methods (review #1: static dispatch). Bring the
// traits into scope so `self.market(...)`, `self.safe_market(...)`,
// `self.load_markets(...)`, … on this Core resolve to the base defaults.
use crate::exchange_generated::ExchangeBase;
use crate::exchange::ExchangeRuntime;
// Dynamic `this[method](...)` re-entries are emitted as
// `self.call_dynamic_checked(...)` (blanket-impl'd on every Core) so an
// unresolvable name raises NotSupported instead of yielding a silent Null.
use crate::exchange::CallDynamicChecked;
use crate::pro::*;


pub struct BingxCore {
    pub parent: crate::exchanges::bingx::BingxCore,
}

impl BingxCore {
    pub fn new(config: Option<crate::Value>) -> Self {
        let mut s = Self { parent: crate::exchanges::bingx::BingxCore::new(config) };
        s.init();
        s
    }

    pub fn init(&mut self) {
        let described = BingxCore::describe(self);
        self.initialize_properties(described);
        <Self as crate::exchange_generated::ExchangeBase>::after_construct(self);
    }

    /// Compatibility no-op. The old pointer-based dispatch needed a post-move
    /// `bind()`; static trait dispatch (review #1) needs no binding, so this
    /// just exists so callers that still call it keep compiling.
    #[inline]
    pub fn bind(&mut self) {}
}

impl crate::exchange::DerivedExchange for BingxCore {
    fn nonce(&self, ) -> crate::Value {
        crate::exchange::DerivedExchange::nonce(&self.parent)
    }
    fn parse_ticker(&self, ticker: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_ticker(&self.parent, ticker, market)
    }
    fn parse_trade(&self, trade: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_trade(&self.parent, trade, market)
    }
    fn parse_order(&self, order: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_order(&self.parent, order, market)
    }
    fn parse_market(&self, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_market(&self.parent, market)
    }
    fn parse_ohlcv(&self, ohlcv: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_ohlcv(&self.parent, ohlcv, market)
    }
    fn parse_order_book(&self, ob: crate::Value, symbol: crate::Value, ts: crate::Value, bk: crate::Value, ak: crate::Value, pk: crate::Value, ak2: crate::Value, ck: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_order_book(&self.parent, ob, symbol, ts, bk, ak, pk, ak2, ck)
    }
    fn parse_balance(&self, response: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_balance(&self.parent, response)
    }
    fn parse_position(&self, position: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_position(&self.parent, position, market)
    }
    fn parse_funding_rate(&self, rate: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_funding_rate(&self.parent, rate, market)
    }
    fn parse_deposit(&self, tx: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_deposit(&self.parent, tx, currency)
    }
    fn parse_deposit_address(&self, depositAddress: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_deposit_address(&self.parent, depositAddress, currency)
    }
    fn parse_last_price(&self, entry: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_last_price(&self.parent, entry, market)
    }
    fn parse_withdrawal(&self, tx: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_withdrawal(&self.parent, tx, currency)
    }
    fn parse_ledger_entry(&self, entry: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_ledger_entry(&self.parent, entry, currency)
    }
    fn parse_transfer(&self, transfer: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_transfer(&self.parent, transfer, currency)
    }
    fn parse_currency(&self, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_currency(&self.parent, currency)
    }
    fn parse_bid_ask(&self, bidask: crate::Value, price_key: crate::Value, amount_key: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_bid_ask(&self.parent, bidask, price_key, amount_key, market)
    }
    fn parse_open_interest(&self, interest: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_open_interest(&self.parent, interest, market)
    }
    fn parse_liquidation(&self, liquidation: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_liquidation(&self.parent, liquidation, market)
    }
    fn parse_funding_rate_history(&self, entry: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_funding_rate_history(&self.parent, entry, market)
    }
    fn parse_margin_modification(&self, data: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_margin_modification(&self.parent, data, market)
    }
    fn parse_account(&self, account: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_account(&self.parent, account)
    }
    fn parse_my_trade(&self, trade: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_my_trade(&self.parent, trade, market)
    }
    fn parse_transaction(&self, transaction: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_transaction(&self.parent, transaction, currency)
    }
    fn parse_borrow_interest(&self, info: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_borrow_interest(&self.parent, info, market)
    }
    fn parse_adl_rank(&self, info: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_adl_rank(&self.parent, info, market)
    }
    fn parse_income(&self, info: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_income(&self.parent, info, market)
    }
    fn parse_greeks(&self, greeks: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_greeks(&self.parent, greeks, market)
    }
    fn parse_margin_mode(&self, margin_mode: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_margin_mode(&self.parent, margin_mode, market)
    }
    fn parse_conversion(&self, conversion: crate::Value, from_currency: crate::Value, to_currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_conversion(&self.parent, conversion, from_currency, to_currency)
    }
    fn parse_borrow_rate(&self, info: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_borrow_rate(&self.parent, info, currency)
    }
    fn parse_leverage(&self, leverage: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_leverage(&self.parent, leverage, market)
    }
    fn parse_market_leverage_tiers(&self, info: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_market_leverage_tiers(&self.parent, info, market)
    }
    fn parse_deposit_withdraw_fee(&self, fee: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_deposit_withdraw_fee(&self.parent, fee, currency)
    }
    fn parse_prediction_trade(&self, trade: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_prediction_trade(&self.parent, trade, market)
    }
    fn parse_prediction_order(&self, order: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_prediction_order(&self.parent, order, market)
    }
    fn parse_prediction_position(&self, position: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_prediction_position(&self.parent, position, market)
    }
    fn create_expired_option_market(&self, symbol: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::create_expired_option_market(&self.parent, symbol)
    }
    fn sign(&self, path: crate::Value, api: crate::Value, method: crate::Value, params: crate::Value, headers: crate::Value, body: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::sign(&self.parent, path, api, method, params, headers, body)
    }
    fn handle_errors(&self, code: crate::Value, reason: crate::Value, url: crate::Value, method: crate::Value, headers: crate::Value, body: crate::Value, response: crate::Value, request_headers: crate::Value, request_body: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::handle_errors(&self.parent, code, reason, url, method, headers, body, response, request_headers, request_body)
    }
}

impl crate::exchange_generated::ExchangeBase for BingxCore {
    fn call_dynamic<'a>(&'a mut self, method: &'a str, args: Vec<crate::Value>)
        -> std::pin::Pin<Box<dyn std::future::Future<Output = crate::Value> + Send + 'a>>
    {
        Box::pin(async move {
            match method {
                "authenticate" => self.authenticate(&args[..]).await,
                "get_message_hash" => self.get_message_hash(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "get_order_book_limit_by_market_type" => self.get_order_book_limit_by_market_type(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "handle_error_message" => self.handle_error_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
                "handle_subscription_status" => self.handle_subscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "keep_alive_listen_key" => self.keep_alive_listen_key(&args[..]).await,
                "load_balance_snapshot" => self.load_balance_snapshot(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null)).await,
                "load_positions_snapshot" => self.load_positions_snapshot(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null)).await,
                "parse_ws_ohlcv" => self.parse_ws_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "parse_ws_position" => self.parse_ws_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "parse_ws_ticker" => self.parse_ws_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "pong" => self.pong(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)).await,
                "un_watch" => self.un_watch(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), args.get(4).cloned().unwrap_or(crate::Value::Null), args.get(5).cloned().unwrap_or(crate::Value::Null), args.get(6).cloned().unwrap_or(crate::Value::Null), &args[7.min(args.len())..]).await,
                "un_watch_ohlcv" => self.un_watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_order_book" => self.un_watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_ticker" => self.un_watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_trades" => self.un_watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_balance" => self.watch_balance(&args[..]).await,
                "watch_my_trades" => self.watch_my_trades(&args[..]).await,
                "watch_ohlcv" => self.watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_order_book" => self.watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_orders" => self.watch_orders(&args[..]).await,
                "watch_positions" => self.watch_positions(&args[..]).await,
                "watch_ticker" => self.watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_trades" => self.watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                // Go-style inheritance: an un-overridden method dispatches to the parent core.
                _ => crate::exchange_generated::ExchangeBase::call_dynamic(&mut self.parent, method, args).await,
            }
        })
    }
}
impl BingxCore {
    /// Synchronous WS handler dispatch — routes a handler-name string (from the
    /// venue's handle_message dispatch table) to the real handler method.
    #[allow(dead_code, unreachable_patterns, clippy::all)]
    pub fn dispatch_ws_handler(&mut self, __name: &crate::Value, args: &[crate::Value]) -> crate::Value {
        let __n = match __name { crate::Value::Str(s) => s.as_ref(), _ => return crate::Value::Null };
        match __n {
            "authenticate" => { crate::exchange_stubs::enqueue_spawn("authenticate", args.to_vec()); crate::Value::Null },
            "get_message_hash" => self.get_message_hash(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "get_order_book_limit_by_market_type" => self.get_order_book_limit_by_market_type(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "handle_balance" => { self.handle_balance(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_delta" => { self.handle_delta(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_error_message" => self.handle_error_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_my_trades" => { self.handle_my_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_ohlcv" => { self.handle_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order" => { self.handle_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order_book" => { self.handle_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_positions" => { self.handle_positions(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_subscription_status" => self.handle_subscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "handle_ticker" => { self.handle_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_trades" => { self.handle_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_un_subscription" => { self.handle_un_subscription(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "keep_alive_listen_key" => { crate::exchange_stubs::enqueue_spawn("keep_alive_listen_key", args.to_vec()); crate::Value::Null },
            "load_balance_snapshot" => { crate::exchange_stubs::enqueue_spawn("load_balance_snapshot", args.to_vec()); crate::Value::Null },
            "load_positions_snapshot" => { crate::exchange_stubs::enqueue_spawn("load_positions_snapshot", args.to_vec()); crate::Value::Null },
            "parse_ws_ohlcv" => self.parse_ws_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "parse_ws_position" => self.parse_ws_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "parse_ws_ticker" => self.parse_ws_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "pong" => { crate::exchange_stubs::enqueue_spawn("pong", args.to_vec()); crate::Value::Null },
            "set_balance_cache" => { self.set_balance_cache(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), args.get(4).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "set_positions_cache" => { self.set_positions_cache(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args[2.min(args.len())..]); crate::Value::Null },
            "un_watch" => { crate::exchange_stubs::enqueue_spawn("un_watch", args.to_vec()); crate::Value::Null },
            "un_watch_ohlcv" => { crate::exchange_stubs::enqueue_spawn("un_watch_ohlcv", args.to_vec()); crate::Value::Null },
            "un_watch_order_book" => { crate::exchange_stubs::enqueue_spawn("un_watch_order_book", args.to_vec()); crate::Value::Null },
            "un_watch_ticker" => { crate::exchange_stubs::enqueue_spawn("un_watch_ticker", args.to_vec()); crate::Value::Null },
            "un_watch_trades" => { crate::exchange_stubs::enqueue_spawn("un_watch_trades", args.to_vec()); crate::Value::Null },
            "watch_balance" => { crate::exchange_stubs::enqueue_spawn("watch_balance", args.to_vec()); crate::Value::Null },
            "watch_my_trades" => { crate::exchange_stubs::enqueue_spawn("watch_my_trades", args.to_vec()); crate::Value::Null },
            "watch_ohlcv" => { crate::exchange_stubs::enqueue_spawn("watch_ohlcv", args.to_vec()); crate::Value::Null },
            "watch_order_book" => { crate::exchange_stubs::enqueue_spawn("watch_order_book", args.to_vec()); crate::Value::Null },
            "watch_orders" => { crate::exchange_stubs::enqueue_spawn("watch_orders", args.to_vec()); crate::Value::Null },
            "watch_positions" => { crate::exchange_stubs::enqueue_spawn("watch_positions", args.to_vec()); crate::Value::Null },
            "watch_ticker" => { crate::exchange_stubs::enqueue_spawn("watch_ticker", args.to_vec()); crate::Value::Null },
            "watch_trades" => { crate::exchange_stubs::enqueue_spawn("watch_trades", args.to_vec()); crate::Value::Null },
            _ => crate::Value::Null,
        }
    }
}

impl std::ops::Deref for BingxCore {
    type Target = crate::exchange::Exchange;
    fn deref(&self) -> &crate::exchange::Exchange { std::ops::Deref::deref(&self.parent) }
}

impl std::ops::DerefMut for BingxCore {
    fn deref_mut(&mut self) -> &mut crate::exchange::Exchange { std::ops::DerefMut::deref_mut(&mut self.parent) }
}

impl BingxCore {
    pub fn describe(&self) -> Value {
        return self.deep_extend(self.parent.describe(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("has".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Bool(true));
        m.insert("watchTrades".to_string(), Value::Bool(true));
        m.insert("watchTradesForSymbols".to_string(), Value::Bool(false));
        m.insert("watchOrderBook".to_string(), Value::Bool(true));
        m.insert("watchOrderBookForSymbols".to_string(), Value::Bool(false));
        m.insert("watchOHLCV".to_string(), Value::Bool(true));
        m.insert("watchOHLCVForSymbols".to_string(), Value::Bool(false));
        m.insert("watchOrders".to_string(), Value::Bool(true));
        m.insert("watchMyTrades".to_string(), Value::Bool(true));
        m.insert("watchTicker".to_string(), Value::Bool(true));
        m.insert("watchTickers".to_string(), Value::Bool(false));
        m.insert("watchBalance".to_string(), Value::Bool(true));
        m.insert("watchPositions".to_string(), Value::Bool(true));
        m.insert("unWatchOHLCV".to_string(), Value::Bool(true));
        m.insert("unWatchOrderBook".to_string(), Value::Bool(true));
        m.insert("unWatchTicker".to_string(), Value::Bool(true));
        m.insert("unWatchTrades".to_string(), Value::Bool(true));
    m
}));
        m.insert("urls".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("test".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("linear".to_string(), Value::Str("wss://vst-open-api-ws.bingx.com/swap-market".into()));
    m
}));
    m
}));
        m.insert("api".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("spot".to_string(), Value::Str("wss://open-api-ws.bingx.com/market".into()));
        m.insert("linear".to_string(), Value::Str("wss://open-api-swap.bingx.com/swap-market".into()));
        m.insert("inverse".to_string(), Value::Str("wss://open-api-cswap-ws.bingx.com/market".into()));
    m
}));
    m
}));
    m
}));
        m.insert("options".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("listenKeyRefreshRate".to_string(), Value::Int(3540000));
        m.insert("ws".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("gunzip".to_string(), Value::Bool(true));
    m
}));
        m.insert("swap".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("timeframes".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("1m".to_string(), Value::Str("1m".into()));
        m.insert("3m".to_string(), Value::Str("3m".into()));
        m.insert("5m".to_string(), Value::Str("5m".into()));
        m.insert("15m".to_string(), Value::Str("15m".into()));
        m.insert("30m".to_string(), Value::Str("30m".into()));
        m.insert("1h".to_string(), Value::Str("1h".into()));
        m.insert("2h".to_string(), Value::Str("2h".into()));
        m.insert("4h".to_string(), Value::Str("4h".into()));
        m.insert("6h".to_string(), Value::Str("6h".into()));
        m.insert("12h".to_string(), Value::Str("12h".into()));
        m.insert("1d".to_string(), Value::Str("1d".into()));
        m.insert("3d".to_string(), Value::Str("3d".into()));
        m.insert("1w".to_string(), Value::Str("1w".into()));
        m.insert("1M".to_string(), Value::Str("1M".into()));
    m
}));
    m
}));
        m.insert("spot".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("timeframes".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("1m".to_string(), Value::Str("1min".into()));
        m.insert("5m".to_string(), Value::Str("5min".into()));
        m.insert("15m".to_string(), Value::Str("15min".into()));
        m.insert("30m".to_string(), Value::Str("30min".into()));
        m.insert("1h".to_string(), Value::Str("60min".into()));
        m.insert("1d".to_string(), Value::Str("1day".into()));
    m
}));
    m
}));
        m.insert("watchBalance".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("fetchBalanceSnapshot".to_string(), Value::Bool(true));
        m.insert("awaitBalanceSnapshot".to_string(), Value::Bool(true));
    m
}));
        m.insert("watchPositions".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("fetchPositionsSnapshot".to_string(), Value::Bool(true));
        m.insert("awaitPositionsSnapshot".to_string(), Value::Bool(false));
    m
}));
        m.insert("watchOrderBook".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("depth".to_string(), Value::Int(100));
    m
}));
        m.insert("watchTrades".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ignoreDuplicates".to_string(), Value::Bool(true));
    m
}));
    m
}));
        m.insert("streaming".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("keepAlive".to_string(), Value::Int(1800000));
    m
}));
    m
})]);

    Value::Null
}

    pub async fn un_watch(&mut self, mut messageHash: Value, mut subMessageHash: Value, mut subscribeHash: Value, mut dataType: Value, mut topic: Value, mut market: Value, mut methodName: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(methodName.clone(), &[market.clone(), params.clone()]); marketType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(methodName, &[market.clone(), params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        if (marketType.as_str() == Some("swap")) {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType, &[]);
        }  else {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), marketType, &[]);
        }
        let mut id: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), id.clone());
                m.insert("dataType".to_string(), dataType);
                m.insert("reqType".to_string(), Value::Str("unsub".into()));
            m
        });
        let mut symbols: Value = Value::from(vec![]);
        if (market != Value::Null) {
            append_to_array(&mut symbols, market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("id".to_string(), id);
                m.insert("subMessageHashes".to_string(), Value::from(vec![subMessageHash]));
                m.insert("messageHashes".to_string(), Value::from(vec![messageHash.clone()]));
                m.insert("symbols".to_string(), symbols);
                m.insert("topic".to_string(), topic);
            m
        });
        let mut symbolsAndTimeframes: Value = self.safe_list_k(params.clone(), "symbolsAndTimeframes", &[]);
        if (symbolsAndTimeframes != Value::Null) {
            if let Value::Dict(__d) = &mut subscription { std::sync::Arc::make_mut(__d).insert("symbolsAndTimeframes".into(), symbolsAndTimeframes); }
            params = self.omit(params.clone(), Value::Str("symbolsAndTimeframes".into()), &[]);
        }
        let __ws_arg_0 = self.extend(request, &[params]);
        return self.watch(url, messageHash, &[__ws_arg_0, subscribeHash, subscription]).await;

    Value::Null
}

/*
 * @method
 * @name bingx#watchTicker
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscribe%20to%2024-hour%20Price%20Change
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20to%2024-hour%20price%20changes
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%2024-Hour%20Price%20Change
 * @param {string} symbol unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn watch_ticker(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol);
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchTicker".into()), &[market.clone(), params.clone()]); marketType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchTicker".into()), &[market.clone(), params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        if (marketType.as_str() == Some("swap")) {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType, &[]);
        }  else {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), marketType.clone(), &[]);
        }
        let mut dataType: Value = Value::Str(format!("{}{}", market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null), Value::Str("@ticker".into())).into());
        let mut messageHash: Value = self.get_message_hash(Value::Str("ticker".into()), &[market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)]);
        let mut uuid: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("dataType".to_string(), dataType);
            m
        });
        if (marketType.as_str() == Some("swap")) {
            if let Value::Dict(__d) = &mut request { std::sync::Arc::make_mut(__d).insert("reqType".into(), Value::Str("sub".into())); }
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid);
            m
        });
        let __ws_arg_1 = self.extend(request, &[params]);
        return self.watch(url, messageHash.clone(), &[__ws_arg_1, messageHash.clone(), subscription]).await;

    Value::Null
}

/*
 * @method
 * @name bingx#unWatchTicker
 * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscribe%20to%2024-hour%20Price%20Change
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20to%2024-hour%20price%20changes
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%2024-Hour%20Price%20Change
 * @param {string} symbol unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn un_watch_ticker(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol);
        let mut dataType: Value = Value::Str(format!("{}{}", market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null), Value::Str("@ticker".into())).into());
        let mut subMessageHash: Value = self.get_message_hash(Value::Str("ticker".into()), &[market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)]);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("unsubscribe::".into()), subMessageHash).into());
        let mut topic: Value = Value::Str("ticker".into());
        let mut methodName: Value = Value::Str("unWatchTicker".into());
        return self.un_watch(messageHash.clone(), subMessageHash, messageHash.clone(), dataType, topic, market, methodName, &[params]).await;

    Value::Null
}

    pub fn handle_ticker(&mut self, mut client: Value, mut message: Value) {
        let __message_empty = indexmap::IndexMap::new();
        let message = message.as_map().unwrap_or(&__message_empty);
        //
        // swap
        //
        //     {
        //         "code": 0,
        //         "dataType": "BTC-USDT@ticker",
        //         "data": {
        //             "e": "24hTicker",
        //             "E": 1706498923556,
        //             "s": "BTC-USDT",
        //             "p": "346.4",
        //             "P": "0.82",
        //             "c": "42432.5",
        //             "L": "0.0529",
        //             "h": "42855.4",
        //             "l": "41578.3",
        //             "v": "64310.9754",
        //             "q": "2728360284.15",
        //             "o": "42086.1",
        //             "O": 1706498922655,
        //             "C": 1706498883023,
        //             "A": "42437.8",
        //             "a": "1.4160",
        //             "B": "42437.1",
        //             "b": "2.5747"
        //         }
        //     }
        //
        // spot
        //
        //     {
        //         "code": 0,
        //         "timestamp": 1706506795473,
        //         "data": {
        //             "e": "24hTicker",
        //             "E": 1706506795472,
        //             "s": "BTC-USDT",
        //             "p": -372.12,
        //             "P": "-0.87%",
        //             "o": 42548.95,
        //             "h": 42696.1,
        //             "l": 41621.29,
        //             "c": 42176.83,
        //             "v": 4943.33,
        //             "q": 208842236.5,
        //             "O": 1706420395472,
        //             "C": 1706506795472,
        //             "A": 42177.23,
        //             "a": 5.14484,
        //             "B": 42176.38,
        //             "b": 5.36117
        //         }
        //     }
        //
        let mut data: Value = (match message.get("data") { Some(__v) if matches!(__v, Value::Dict(_)) => __v.clone(), _ => Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) });
        let mut marketId: Value = self.safe_string_k(data.clone(), "s", &[]);
        // const marketId = messageHash.split('@')[0];
        let mut isSwap: bool = Value::Int(get_value(&client, &Value::Str("url".into())).as_str().and_then(|__s| __s.find("swap")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64);
        let mut marketType: Value = (if isSwap { Value::Str("swap".into()) } else { Value::Str("spot".into()) });
        let mut market: Value = self.safe_market(&[marketId, Value::Null, Value::Null, marketType]);
        let mut symbol: Value = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        // the Coin-M stream is a distinct endpoint, so it identifies an inverse
        // ticker even when the market id could not be resolved
        let mut inverseUrl: Value = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), Value::Str("inverse".into()), &[]);
        let mut isInverse: Value = Value::Bool((inverseUrl != Value::Null) && (get_index_of(&get_value(&client, &Value::Str("url".into())), &inverseUrl).as_f64() == Some(0.0)));
        let mut ticker: Value = self.parse_ws_ticker(data, &[market, isInverse]);
        if let Value::Dict(__d) = &mut self.tickers { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), ticker.clone()); }
        client.resolve(&[ticker.clone(), self.get_message_hash(Value::Str("ticker".into()), &[symbol])]);
        if ((match message.get("dataType") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null }).as_str() == Some("all@ticker")) {
            client.resolve(&[ticker, self.get_message_hash(Value::Str("ticker".into()), &[])]);
        }
}

    pub fn parse_ws_ticker(&self, mut message: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        let mut isInverse = get_arg(optional_args, 1, Value::Null);
        //
        //     {
        //         "e": "24hTicker",
        //         "E": 1706498923556,
        //         "s": "BTC-USDT",
        //         "p": "346.4",
        //         "P": "0.82",
        //         "c": "42432.5",
        //         "L": "0.0529",
        //         "h": "42855.4",
        //         "l": "41578.3",
        //         "v": "64310.9754",
        //         "q": "2728360284.15",
        //         "o": "42086.1",
        //         "O": 1706498922655,
        //         "C": 1706498883023,
        //         "A": "42437.8",
        //         "a": "1.4160",
        //         "B": "42437.1",
        //         "b": "2.5747"
        //     }
        //
        let mut timestamp: Value = self.safe_integer_k(message.clone(), "C", &[]);
        let mut marketId: Value = self.safe_string_k(message.clone(), "s", &[]);
        market = self.safe_market(&[marketId, market.clone()]);
        let mut close: Value = self.safe_string_k(message.clone(), "c", &[]);
        // Coin-M m is coin volume; v is contracts and q is already USD turnover.
        // prefer the caller's stream-derived flag so an unresolved market id on
        // the Coin-M endpoint does not silently fall back to the contract count
        let mut inverse: Value = (if (isInverse == Value::Null) { (Value::Bool(market.as_map().and_then(|__m| __m.get("inverse")).cloned().unwrap_or(Value::Null).as_bool() == Some(true))) } else { isInverse });
        let mut baseVolumeKey: Value = (if is_true(&inverse) { Value::Str("m".into()) } else { Value::Str("v".into()) });
        return self.safe_ticker(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp));
        m.insert("high".to_string(), self.safe_string_k(message.clone(), "h", &[]));
        m.insert("low".to_string(), self.safe_string_k(message.clone(), "l", &[]));
        m.insert("bid".to_string(), self.safe_string_k(message.clone(), "B", &[]));
        m.insert("bidVolume".to_string(), self.safe_string_k(message.clone(), "b", &[]));
        m.insert("ask".to_string(), self.safe_string_k(message.clone(), "A", &[]));
        m.insert("askVolume".to_string(), self.safe_string_k(message.clone(), "a", &[]));
        m.insert("vwap".to_string(), Value::Null);
        m.insert("open".to_string(), self.safe_string_k(message.clone(), "o", &[]));
        m.insert("close".to_string(), close.clone());
        m.insert("last".to_string(), close);
        m.insert("previousClose".to_string(), Value::Null);
        m.insert("change".to_string(), self.safe_string_k(message.clone(), "p", &[]));
        m.insert("percentage".to_string(), Value::Null);
        m.insert("average".to_string(), Value::Null);
        m.insert("baseVolume".to_string(), self.safe_string(message.clone(), baseVolumeKey, &[]));
        m.insert("quoteVolume".to_string(), self.safe_string_k(message.clone(), "q", &[]));
        m.insert("info".to_string(), message);
    m
}), &[market]);

    Value::Null
}

    pub fn get_order_book_limit_by_market_type(&self, mut marketType: Value, optional_args: &[Value]) -> Value {
        let mut limit = get_arg(optional_args, 0, Value::Null);
        if (limit == Value::Null) {
            limit = Value::Int(100);
        }  else {
            if (marketType.as_str() == Some("swap")) || (marketType.as_str() == Some("future")) {
                limit = self.find_nearest_ceiling(Value::from(vec![Value::Int(5), Value::Int(10), Value::Int(20), Value::Int(50), Value::Int(100)]), limit.clone());
            }  else if (marketType.as_str() == Some("spot")) {
                limit = self.find_nearest_ceiling(Value::from(vec![Value::Int(20), Value::Int(100)]), limit.clone());
            }
        }
        return limit;

    Value::Null
}

    pub fn get_message_hash(&self, mut unifiedChannel: Value, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut extra = get_arg(optional_args, 1, Value::Null);
        let mut hash: Value = unifiedChannel;
        if (symbol != Value::Null) {
            hash = Value::Str(format!("{}{}", hash, Value::Str(format!("{}{}", Value::Str("::".into()), symbol).into())).into());
        }  else {
            hash = Value::Str(format!("{}{}", hash, Value::Str("s".into())).into()); // tickers, orderbooks, ohlcvs, etc ...
        }
        if (extra != Value::Null) {
            hash = Value::Str(format!("{}{}", hash, Value::Str(format!("{}{}", Value::Str("::".into()), extra).into())).into());
        }
        return hash;

    Value::Null
}

/*
 * @method
 * @name bingx#watchTrades
 * @description watches information on multiple trades made in a market
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscription%20transaction%20by%20transaction
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20the%20Latest%20Trade%20Detail
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscription%20transaction%20by%20transaction
 * @param {string} symbol unified market symbol of the market orders were made in
 * @param {int} [since] the earliest time in ms to fetch orders for
 * @param {int} [limit] the maximum number of order structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
 */
    pub async fn watch_trades(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut since = get_arg(optional_args, 0, Value::Null);
        let mut limit = get_arg(optional_args, 1, Value::Null);
        let mut params = get_arg(optional_args, 2, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        symbol = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchTrades".into()), &[market.clone(), params.clone()]); marketType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchTrades".into()), &[market.clone(), params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        if (marketType.as_str() == Some("swap")) {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType, &[]);
        }  else {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), marketType.clone(), &[]);
        }
        let mut rawHash: Value = Value::Str(format!("{}{}", market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null), Value::Str("@trade".into())).into());
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("trade::".into()), symbol).into());
        let mut uuid: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("dataType".to_string(), rawHash);
            m
        });
        if (marketType.as_str() == Some("swap")) {
            if let Value::Dict(__d) = &mut request { std::sync::Arc::make_mut(__d).insert("reqType".into(), Value::Str("sub".into())); }
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid);
            m
        });
        let __ws_arg_2 = self.extend(request, &[params]);
        let mut trades: Value = self.watch(url, messageHash.clone(), &[__ws_arg_2, messageHash.clone(), subscription]).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(symbol, limit.clone());
        }
        let mut result: Value = self.filter_by_since_limit(trades, &[since, limit, Value::Str("timestamp".into()), Value::Bool(true)]);
        if is_equal(&self.handle_option(Value::Str("watchTrades".into()), Value::Str("ignoreDuplicates".into()), &[Value::Bool(true)]), &Value::Bool(true)) {
            let mut filtered: Value = self.remove_repeated_trades_from_array(result.clone());
            filtered = self.sort_by(filtered.clone(), Value::Str("timestamp".into()), &[]);
            return filtered;
        }
        return result;

    Value::Null
}

/*
 * @method
 * @name bingx#unWatchTrades
 * @description unsubscribes from the trades channel
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscription%20transaction%20by%20transaction
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20the%20Latest%20Trade%20Detail
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscription%20transaction%20by%20transaction
 * @param {string} symbol unified symbol of the market to fetch trades for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.name] the name of the method to call, 'trade' or 'aggTrade', default is 'trade'
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
 */
    pub async fn un_watch_trades(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol);
        let mut dataType: Value = Value::Str(format!("{}{}", market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null), Value::Str("@trade".into())).into());
        let mut subMessageHash: Value = self.get_message_hash(Value::Str("trade".into()), &[market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)]);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("unsubscribe::".into()), subMessageHash).into());
        let mut topic: Value = Value::Str("trades".into());
        let mut methodName: Value = Value::Str("unWatchTrades".into());
        return self.un_watch(messageHash.clone(), subMessageHash, messageHash.clone(), dataType, topic, market, methodName, &[params]).await;

    Value::Null
}

    pub fn handle_trades(&mut self, mut client: Value, mut message: Value) {
        let __message_empty = indexmap::IndexMap::new();
        let message = message.as_map().unwrap_or(&__message_empty);
        //
        // spot: first snapshot
        //
        //    {
        //      "id": "d83b78ce-98be-4dc2-b847-12fe471b5bc5",
        //      "code": 0,
        //      "msg": "SUCCESS",
        //      "timestamp": 1690214699854
        //    }
        //
        // spot: subsequent updates
        //
        //     {
        //         "code": 0,
        //         "data": {
        //           "E": 1690214529432,
        //           "T": 1690214529386,
        //           "e": "trade",
        //           "m": true,
        //           "p": "29110.19",
        //           "q": "0.1868",
        //           "s": "BTC-USDT",
        //           "t": "57903921"
        //         },
        //         "dataType": "BTC-USDT@trade",
        //         "success": true
        //     }
        //
        // linear swap: first snapshot
        //
        //    {
        //        "id": "2aed93b1-6e1e-4038-aeba-f5eeaec2ca48",
        //        "code": 0,
        //        "msg": '',
        //        "dataType": '',
        //        "data": null
        //    }
        //
        // linear swap: subsequent updates
        //
        //    {
        //        "code": 0,
        //        "dataType": "BTC-USDT@trade",
        //        "data": [
        //            {
        //                "q": "0.0421",
        //                "p": "29023.5",
        //                "T": 1690221401344,
        //                "m": false,
        //                "s": "BTC-USDT"
        //            },
        //            ...
        //        ]
        //    }
        //
        // inverse swap: first snapshot
        //
        //     {
        //         "code": 0,
        //         "id": "a2e482ca-f71b-42f8-a83a-8ff85a713e64",
        //         "msg": "SUCCESS",
        //         "timestamp": 1722920589426
        //     }
        //
        // inverse swap: subsequent updates
        //
        //     {
        //         "code": 0,
        //         "dataType": "BTC-USD@trade",
        //         "data": {
        //             "e": "trade",
        //             "E": 1722920589665,
        //             "s": "BTC-USD",
        //             "t": "39125001",
        //             "p": "55360.0",
        //             "q": "1",
        //             "T": 1722920589582,
        //             "m": false
        //         }
        //     }
        //
        let mut data: Value = (match message.get("data") { Some(__v) if !matches!(__v, Value::Null) && !matches!(__v, Value::Str(__s) if __s.is_empty()) => __v.clone(), _ => Value::from(vec![]) });
        let mut rawHash: Value = (match message.get("dataType") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Str("".into()) });
        let mut marketId: Value = split(&rawHash, &Value::Str("@".into())).as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null);
        let mut isSwap: bool = Value::Int(get_value(&client, &Value::Str("url".into())).as_str().and_then(|__s| __s.find("swap")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64);
        let mut marketType: Value = (if isSwap { Value::Str("swap".into()) } else { Value::Str("spot".into()) });
        let mut market: Value = self.safe_market(&[marketId, Value::Null, Value::Null, marketType]);
        let mut symbol: Value = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("trade::".into()), symbol).into());
        let mut trades: Value = Value::Null;
        if (matches!(&data, Value::Arr(_))) {
            trades = self.parse_trades(data.clone(), &[market.clone()]);
        }  else {
            trades = Value::from(vec![self.parse_trade(data, &[market])]);
        }
        let mut stored: Value = self.safe_value(self.trades.clone(), symbol.clone(), &[]);
        if (stored == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            stored = ArrayCache::new(limit);
            if let Value::Dict(__d) = &mut self.trades { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), stored.clone()); }
        }
        {
                        let mut j: Value = Value::Int(0);
            let mut __for_first_91: bool = true;
            while { if !__for_first_91 { j = (match (&(j), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_91 = false; j.as_f64().unwrap_or(f64::NAN) < ((trades.len() as i64) as f64) } {
            stored.append(trades.as_array().and_then(|__arr| match &j { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null));
        }
        }
        client.resolve(&[stored, messageHash]);
}

/*
 * @method
 * @name bingx#watchOrderBook
 * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscribe%20Market%20Depth%20Data
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Partial%20Order%20Book%20Depth
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%20Limited%20Depth
 * @param {string} symbol unified symbol of the market to fetch the order book for
 * @param {int} [limit] the maximum amount of order book entries to return
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} an [order book structure]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn watch_order_book(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut limit = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol);
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchOrderBook".into()), &[market.clone(), params.clone()]); marketType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchOrderBook".into()), &[market.clone(), params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        if (marketType.as_str() == Some("swap")) {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType, &[]);
        }  else {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), marketType.clone(), &[]);
        }
        let mut options: Value = self.safe_dict_k(self.options.clone(), "watchOrderBook", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut depth: Value = self.safe_integer_k(options, "depth", &[Value::Int(100)]);
        let mut subscriptionHash: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null), Value::Str("@".into())).into()), Value::Str("depth".into())).into()), self.number_to_string(depth)).into());
        let mut messageHash: Value = self.get_message_hash(Value::Str("orderbook".into()), &[market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)]);
        let mut uuid: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("dataType".to_string(), subscriptionHash.clone());
            m
        });
        if (marketType.as_str() == Some("swap")) {
            if let Value::Dict(__d) = &mut request { std::sync::Arc::make_mut(__d).insert("reqType".into(), Value::Str("sub".into())); }
        }
        let mut subscriptionArgs: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        if (market.as_map().and_then(|__m| __m.get("inverse")).cloned().unwrap_or(Value::Null).as_bool() == Some(true)) {
            subscriptionArgs = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("unsubscribe".to_string(), Value::Bool(false));
                    m.insert("count".to_string(), limit.clone());
                    m.insert("params".to_string(), params.clone());
                m
            });
        }  else {
            subscriptionArgs = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid);
                    m.insert("unsubscribe".to_string(), Value::Bool(false));
                    m.insert("level".to_string(), limit.clone());
                    m.insert("params".to_string(), params.clone());
                m
            });
        }
        let __ws_arg_3 = self.deep_extend(request, &[params]);
        let mut orderbook: Value = self.watch(url, messageHash, &[__ws_arg_3, subscriptionHash, subscriptionArgs]).await;
        return orderbook.limit();

    Value::Null
}

/*
 * @method
 * @name bingx#unWatchOrderBook
 * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscribe%20Market%20Depth%20Data
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Partial%20Order%20Book%20Depth
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%20Limited%20Depth
 * @param {string} symbol unified symbol of the market
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn un_watch_order_book(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol);
        let mut options: Value = self.safe_dict_k(self.options.clone(), "watchOrderBook", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut depth: Value = self.safe_integer_k(options, "depth", &[Value::Int(100)]);
        let mut subMessageHash: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null), Value::Str("@".into())).into()), Value::Str("depth".into())).into()), self.number_to_string(depth)).into());
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("unsubscribe::".into()), subMessageHash).into());
        let mut topic: Value = Value::Str("orderbook".into());
        let mut methodName: Value = Value::Str("unWatchOrderBook".into());
        return self.un_watch(messageHash.clone(), subMessageHash.clone(), messageHash.clone(), subMessageHash.clone(), topic, market, methodName, &[params]).await;

    Value::Null
}

    pub fn handle_delta(&self, mut bookside: Value, mut delta: Value) {
        let mut price: Value = self.safe_float2(delta.clone(), Value::Int(0), Value::Str("p".into()), &[]);
        let mut amount: Value = self.safe_float2(delta, Value::Int(1), Value::Str("a".into()), &[]);
        bookside.store(price, amount);
}

    pub fn handle_order_book(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        // spot
        //
        //     {
        //         "code":0,
        //         "data":
        //         {
        //             "asks":[
        //                 ["84119.73","0.000011"],
        //                 ["84116.52","0.000014"],
        //                 ["84116.40","0.000039"]
        //             ],
        //             "bids":[
        //                 ["83656.98","2.570805"],
        //                 ["83655.51","0.000347"],
        //                 ["83654.59","0.000082"]
        //             ],
        //             "lastUpdateId":13565694850
        //         },
        //         "dataType":"BTC-USDT@depth100",
        //         "success":true,
        //         "timestamp":1743241379958
        //     }
        //
        // linear swap
        //
        //     {
        //         "code":0,
        //         "dataType":"BTC-USDT@depth100@500ms",
        //         "ts":1743241563651,
        //         "data":
        //         {
        //             "bids":[
        //                 ["83363.2","0.1908"],
        //                 ["83360.0","0.0003"],
        //                 ["83356.5","0.0245"],
        //             ],
        //             "asks":[
        //                 ["83495.0","0.0024"],
        //                 ["83490.0","0.0001"],
        //                 ["83488.0","0.0004"],
        //             ]
        //         }
        //     }
        //
        // inverse swap
        //
        //     {
        //         "code":0,
        //         "dataType":"BTC-USD@depth100",
        //         "data":{
        //             "symbol":"BTC-USD",
        //             "bids":[
        //                 {"p":"83411.2","a":"2.979216","v":"2485.0"},
        //                 {"p":"83411.1","a":"1.592114","v":"1328.0"},
        //                 {"p":"83410.8","a":"2.656730","v":"2216.0"},
        //             ],
        //             "asks":[
        //                 {"p":"88200.0","a":"0.344671","v":"304.0"},
        //                 {"p":"88023.8","a":"0.045442","v":"40.0"},
        //                 {"p":"88001.0","a":"0.003409","v":"3.0"},
        //             ],
        //             "aggPrecision":"0.1",
        //             "timestamp":1743242290710
        //         }
        //     }
        //
        let mut data: Value = (match __pro_message.get("data").cloned() { Some(__v) if matches!(__v, Value::Dict(_)) => __v, _ => Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) });
        let mut dataType: Value = (match __pro_message.get("dataType").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Str("".into()) });
        let mut parts: Value = split(&dataType, &Value::Str("@".into()));
        let mut firstPart: Value = parts.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null);
        let mut isAllEndpoint: bool = firstPart.as_str() == Some("all");
        let mut marketId: Value = self.safe_string_k(data.clone(), "symbol", &[firstPart]);
        let mut isSwap: bool = Value::Int(get_value(&client, &Value::Str("url".into())).as_str().and_then(|__s| __s.find("swap")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64);
        let mut marketType: Value = (if isSwap { Value::Str("swap".into()) } else { Value::Str("spot".into()) });
        let mut market: Value = self.safe_market(&[marketId, Value::Null, Value::Null, marketType]);
        let mut symbol: Value = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        let mut orderbook: Value = self.safe_value(self.orderbooks.clone(), symbol.clone(), &[]);
        if (orderbook == Value::Null) {
            // const limit = [ 5, 10, 20, 50, 100 ]
            let mut subscriptionHash: Value = dataType;
            let mut subscription: Value = get_value(&get_value(&client, &Value::Str("subscriptions".into())), &subscriptionHash);
            // see handleOHLCV — subscription.limit may be missing for non-orderbook callers;
            // default to a reasonable depth instead of throwing NPE in the Java port.
            let mut limit: Value = self.safe_integer_k(subscription, "limit", &[Value::Int(100)]);
            { let __be_tmp = self.order_book(&[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), limit]); if let Value::Dict(__d) = &mut self.orderbooks { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), __be_tmp); } }
        }
        orderbook = get_value(&self.orderbooks, &symbol);
        let mut snapshot: Value = Value::Null;
        let mut timestamp: Value = self.safe_integer2(message, Value::Str("timestamp".into()), Value::Str("ts".into()), &[]);
        timestamp = self.safe_integer2(data.clone(), Value::Str("timestamp".into()), Value::Str("ts".into()), &[timestamp.clone()]);
        if (market.as_map().and_then(|__m| __m.get("inverse")).cloned().unwrap_or(Value::Null).as_bool() == Some(true)) {
            snapshot = self.parse_order_book(data.clone(), symbol.clone(), &[timestamp.clone(), Value::Str("bids".into()), Value::Str("asks".into()), Value::Str("p".into()), Value::Str("a".into())]);
        }  else {
            snapshot = self.parse_order_book(data.clone(), symbol.clone(), &[timestamp, Value::Str("bids".into()), Value::Str("asks".into()), Value::Int(0), Value::Int(1)]);
        }
        let mut nonce: Value = self.safe_integer_k(data, "lastUpdateId", &[]);
        add_element_to_object(&mut snapshot, &Value::Str("nonce".into()), nonce);
        orderbook.reset(snapshot);
        let mut messageHash: Value = self.get_message_hash(Value::Str("orderbook".into()), &[symbol]);
        client.resolve(&[orderbook.clone(), messageHash]);
        // resolve for "all"
        if isAllEndpoint {
            let mut messageHashForAll: Value = self.get_message_hash(Value::Str("orderbook".into()), &[]);
            client.resolve(&[orderbook, messageHashForAll]);
        }
}

    pub fn parse_ws_ohlcv(&self, mut ohlcv: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        let __market_empty = indexmap::IndexMap::new();
        let market = market.as_map().unwrap_or(&__market_empty);
        //
        //    {
        //        "c": "28909.0",
        //        "o": "28915.4",
        //        "h": "28915.4",
        //        "l": "28896.1",
        //        "v": "27.6919",
        //        "T": 1696687499999,
        //        "t": 1696687440000
        //    }
        //
        // for spot, opening-time (t) is used instead of closing-time (T), to be compatible with fetchOHLCV
        // for linear swap, (T) is the opening time
        let mut isSpot: bool = (match market.get("spot") { Some(Value::Bool(__b)) => Value::Bool(*__b), _ => Value::Null }).as_bool() == Some(true);
        let mut isInverse: bool = (match market.get("inverse") { Some(Value::Bool(__b)) => Value::Bool(*__b), _ => Value::Null }).as_bool() == Some(true);
        let mut timestamp: Value = (if isSpot { Value::Str("t".into()) } else { Value::Str("T".into()) });
        if ((match market.get("swap") { Some(Value::Bool(__b)) => Value::Bool(*__b), _ => Value::Null }).as_bool() == Some(true)) {
            timestamp = (if isInverse { Value::Str("t".into()) } else { Value::Str("T".into()) });
        }
        return Value::from(vec![self.safe_integer(ohlcv.clone(), timestamp, &[]), self.safe_number_k(ohlcv.clone(), "o", &[]), self.safe_number_k(ohlcv.clone(), "h", &[]), self.safe_number_k(ohlcv.clone(), "l", &[]), self.safe_number_k(ohlcv.clone(), "c", &[]), self.safe_number_k(ohlcv, "v", &[])]);

    Value::Null
}

    pub fn handle_ohlcv(&mut self, mut client: Value, mut message: Value) {
        let __message_empty = indexmap::IndexMap::new();
        let message = message.as_map().unwrap_or(&__message_empty);
        //
        // spot:
        //
        //   {
        //       "code": 0,
        //       "data": {
        //         "E": 1696687498608,
        //         "K": {
        //           "T": 1696687499999,
        //           "c": "27917.829",
        //           "h": "27918.427",
        //           "i": "1min",
        //           "l": "27917.7",
        //           "n": 262,
        //           "o": "27917.91",
        //           "q": "25715.359197",
        //           "s": "BTC-USDT",
        //           "t": 1696687440000,
        //           "v": "0.921100"
        //         },
        //         "e": "kline",
        //         "s": "BTC-USDT"
        //       },
        //       "dataType": "BTC-USDT@kline_1min",
        //       "success": true
        //   }
        //
        // linear swap:
        //
        //    {
        //        "code": 0,
        //        "dataType": "BTC-USDT@kline_1m",
        //        "s": "BTC-USDT",
        //        "data": [
        //            {
        //            "c": "28909.0",
        //            "o": "28915.4",
        //            "h": "28915.4",
        //            "l": "28896.1",
        //            "v": "27.6919",
        //            "T": 1690907580000
        //            }
        //        ]
        //    }
        //
        // inverse swap:
        //
        //     {
        //         "code": 0,
        //         "timestamp": 1723769354547,
        //         "dataType": "BTC-USD@kline_1m",
        //         "data": {
        //             "t": 1723769340000,
        //             "o": 57485.1,
        //             "c": 57468,
        //             "l": 57464.9,
        //             "h": 57485.1,
        //             "a": 0.189663,
        //             "v": 109,
        //             "u": 92,
        //             "s": "BTC-USD"
        //         }
        //     }
        //
        let mut isSwap: bool = Value::Int(get_value(&client, &Value::Str("url".into())).as_str().and_then(|__s| __s.find("swap")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64);
        let mut dataType: Value = (match message.get("dataType") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Str("".into()) });
        let mut parts: Value = split(&dataType, &Value::Str("@".into()));
        let mut firstPart: Value = parts.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null);
        let mut isAllEndpoint: bool = firstPart.as_str() == Some("all");
        let mut marketId: Value = (match message.get("s") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => firstPart });
        let mut marketType: Value = (if isSwap { Value::Str("swap".into()) } else { Value::Str("spot".into()) });
        let mut market: Value = self.safe_market(&[marketId, Value::Null, Value::Null, marketType.clone()]);
        let mut candles: Value = Value::Null;
        if isSwap {
            if (market.as_map().and_then(|__m| __m.get("inverse")).cloned().unwrap_or(Value::Null).as_bool() == Some(true)) {
                candles = Value::from(vec![(match message.get("data") { Some(__v) if matches!(__v, Value::Dict(_)) => __v.clone(), _ => Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) })]);
            }  else {
                candles = (match message.get("data") { Some(__v) if matches!(__v, Value::Arr(_)) => __v.clone(), _ => Value::from(vec![]) });
            }
        }  else {
            let mut data: Value = (match message.get("data") { Some(__v) if matches!(__v, Value::Dict(_)) => __v.clone(), _ => Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) });
            candles = Value::from(vec![self.safe_dict_k(data, "K", &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})])]);
        }
        let mut symbol: Value = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        { let __be_tmp = self.safe_dict(self.ohlcvs.clone(), symbol.clone(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})]); if let Value::Dict(__d) = &mut self.ohlcvs { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), __be_tmp); } }
        let mut rawTimeframe: Value = split(&dataType, &Value::Str("_".into())).as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null);
        let mut marketOptions: Value = self.safe_dict(self.options.clone(), marketType, &[]);
        let mut timeframes: Value = self.safe_dict_k(marketOptions, "timeframes", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut unifiedTimeframe: Value = self.find_timeframe(rawTimeframe.clone(), &[timeframes]);
        if (self.safe_value(get_value(&self.ohlcvs, &symbol), rawTimeframe, &[]) == Value::Null) {
            let mut subscriptionHash: Value = dataType;
            let mut subscription: Value = get_value(&get_value(&client, &Value::Str("subscriptions".into())), &subscriptionHash);
            // subscription.limit is only set when watchOHLCV registers the subscription;
            // when handleMessage routes a non-OHLCV-originated subscription here (or the
            // subscription dict was reset on reconnect), fall back to the OHLCVLimit option.
            let mut limit: Value = self.safe_integer_k(subscription, "limit", &[self.safe_integer(self.options.clone(), Value::Str("OHLCVLimit".into()), &[Value::Int(1000)])]);
            add_element_to_object(get_value_mut(&mut self.ohlcvs, &symbol), &unifiedTimeframe, ArrayCacheByTimestamp::new(limit));
        }
        let mut stored: Value = get_value(&get_value(&self.ohlcvs, &symbol), &unifiedTimeframe);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_92: bool = true;
            while { if !__for_first_92 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_92 = false; i.as_f64().unwrap_or(f64::NAN) < ((candles.len() as i64) as f64) } {
            let mut candle: Value = candles.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut parsed: Value = self.parse_ws_ohlcv(candle, &[market.clone()]);
            stored.append(parsed);
        }
        }
        let mut resolveData: Value = Value::from(vec![symbol.clone(), unifiedTimeframe.clone(), stored]);
        let mut messageHash: Value = self.get_message_hash(Value::Str("ohlcv".into()), &[symbol, unifiedTimeframe.clone()]);
        client.resolve(&[resolveData.clone(), messageHash]);
        // resolve for "all"
        if isAllEndpoint {
            let mut messageHashForAll: Value = self.get_message_hash(Value::Str("ohlcv".into()), &[Value::Null, unifiedTimeframe]);
            client.resolve(&[resolveData, messageHashForAll]);
        }
}

/*
 * @method
 * @name bingx#watchOHLCV
 * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/K-line%20Streamst
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20K-Line%20Data
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%20Latest%20Trading%20Pair%20K-Line
 * @param {string} symbol unified symbol of the market to fetch OHLCV data for
 * @param {string} timeframe the length of time each candle represents
 * @param {int} [since] timestamp in ms of the earliest candle to fetch
 * @param {int} [limit] the maximum amount of candles to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
 */
    pub async fn watch_ohlcv(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut timeframe = get_arg(optional_args, 0, Value::Str("1m".into()));
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchOHLCV".into()), &[market.clone(), params.clone()]); marketType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchOHLCV".into()), &[market.clone(), params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        if (marketType.as_str() == Some("swap")) {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType, &[]);
        }  else {
            url = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), marketType.clone(), &[]);
        }
        if (url == Value::Null) {
            panic!("{}", crate::exchange_errors::bad_request(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" watchOHLCV is not supported for ".into())).into()), marketType).into()), Value::Str(" markets.".into()))));
        }
        let mut options: Value = self.safe_dict(self.options.clone(), marketType.clone(), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut timeframes: Value = self.safe_dict_k(options, "timeframes", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut rawTimeframe: Value = self.safe_string(timeframes, timeframe.clone(), &[timeframe.clone()]);
        let mut messageHash: Value = self.get_message_hash(Value::Str("ohlcv".into()), &[market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null), timeframe]);
        let mut subscriptionHash: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null), Value::Str("@kline_".into())).into()), rawTimeframe).into());
        let mut uuid: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("dataType".to_string(), subscriptionHash.clone());
            m
        });
        if (marketType.as_str() == Some("swap")) {
            if let Value::Dict(__d) = &mut request { std::sync::Arc::make_mut(__d).insert("reqType".into(), Value::Str("sub".into())); }
        }
        let mut subscriptionArgs: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid);
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("interval".to_string(), rawTimeframe);
                m.insert("params".to_string(), params.clone());
            m
        });
        let __ws_arg_4 = self.extend(request, &[params]);
        let mut result: Value = self.watch(url, messageHash, &[__ws_arg_4, subscriptionHash, subscriptionArgs]).await;
        let mut ohlcv: Value = get_value(&result, &Value::Int(2));
        if is_true(&self.newUpdates) {
            limit = ohlcv.get_limit(symbol, limit.clone());
        }
        return self.filter_by_since_limit(ohlcv, &[since, limit, Value::Int(0), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bingx#unWatchOHLCV
 * @description unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/K-line%20Streamst
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20K-Line%20Data
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%20Latest%20Trading%20Pair%20K-Line
 * @param {string} symbol unified symbol of the market to fetch OHLCV data for
 * @param {string} timeframe the length of time each candle represents
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
 */
    pub async fn un_watch_ohlcv(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut timeframe = get_arg(optional_args, 0, Value::Str("1m".into()));
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol);
        let mut options: Value = self.safe_dict(self.options.clone(), market.as_map().and_then(|__m| __m.get("type")).cloned().unwrap_or(Value::Null), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut timeframes: Value = self.safe_dict_k(options, "timeframes", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut rawTimeframe: Value = self.safe_string(timeframes, timeframe.clone(), &[timeframe.clone()]);
        let mut subMessageHash: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null), Value::Str("@kline_".into())).into()), rawTimeframe).into());
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("unsubscribe::".into()), subMessageHash).into());
        let mut topic: Value = Value::Str("ohlcv".into());
        let mut methodName: Value = Value::Str("unWatchOHLCV".into());
        let mut symbolsAndTimeframes: Value = Value::from(vec![Value::from(vec![market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null), timeframe])]);
        if let Value::Dict(__d) = &mut params { std::sync::Arc::make_mut(__d).insert("symbolsAndTimeframes".into(), symbolsAndTimeframes); }
        return self.un_watch(messageHash.clone(), subMessageHash.clone(), messageHash.clone(), subMessageHash.clone(), topic, market, methodName, &[params]).await;

    Value::Null
}

/*
 * @method
 * @name bingx#watchOrders
 * @description watches information on multiple orders made by the user
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Account%20Data/order%20update%20event
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Account%20Data/Order%20update%20push
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Account%20Data/Order%20update%20push
 * @param {string} [symbol] unified market symbol of the market orders are made in
 * @param {int} [since] the earliest time in ms to watch orders for
 * @param {int} [limit] the maximum number of order structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
 */
    pub async fn watch_orders(&mut self, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut type_var: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut market: Value = Value::Null;
        if (symbol != Value::Null) {
            market = self.market(symbol.clone());
            symbol = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        }
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchOrders".into()), &[market.clone(), params.clone()]); type_var = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchOrders".into()), &[market.clone(), params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut isSpot: bool = type_var.as_str() == Some("spot");
        let mut spotHash: Value = Value::Str("spot:private".into());
        let mut swapHash: Value = Value::Str("swap:private".into());
        let mut subscriptionHash: Value = (if isSpot { spotHash } else { swapHash });
        let mut spotMessageHash: Value = Value::Str("spot:order".into());
        let mut swapMessageHash: Value = Value::Str("swap:order".into());
        let mut messageHash: Value = (if isSpot { spotMessageHash } else { swapMessageHash });
        if (market != Value::Null) {
            messageHash = Value::Str(format!("{}{}", messageHash, Value::Str(format!("{}{}", Value::Str(":".into()), symbol).into())).into());
        }
        let mut uuid: Value = self.uuid(&[]);
        let mut baseUrl: Value = Value::Null;
        let mut request: Value = Value::Null;
        if (type_var.as_str() == Some("swap")) {
            if (subType.as_str() == Some("inverse")) {
                panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" watchOrders is not supported for inverse swap markets yet".into()))));
            }
            baseUrl = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType, &[]);
        }  else {
            baseUrl = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), type_var, &[]);
            request = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("reqType".to_string(), Value::Str("sub".into()));
                    m.insert("dataType".to_string(), Value::Str("spot.executionReport".into()));
                m
            });
        }
        let mut url: Value = add(&Value::Str(format!("{}{}", baseUrl, Value::Str("?listenKey=".into())).into()), &self.options.as_map().and_then(|__m| __m.get("listenKey")).cloned().unwrap_or(Value::Null));
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid);
            m
        });
        let mut orders: Value = self.watch(url, messageHash, &[request, subscriptionHash, subscription]).await;
        if is_true(&self.newUpdates) {
            limit = orders.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(orders, &[symbol, since, limit, Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bingx#watchMyTrades
 * @description watches information on multiple trades made by the user
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Account%20Data/order%20update%20event
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Account%20Data/Order%20update%20push
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Account%20Data/Order%20update%20push
 * @param {string} [symbol] unified market symbol of the market the trades are made in
 * @param {int} [since] the earliest time in ms to watch trades for
 * @param {int} [limit] the maximum number of trade structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=trade-structure}
 */
    pub async fn watch_my_trades(&mut self, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut type_var: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut market: Value = Value::Null;
        if (symbol != Value::Null) {
            market = self.market(symbol.clone());
            symbol = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        }
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchMyTrades".into()), &[market.clone(), params.clone()]); type_var = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchMyTrades".into()), &[market.clone(), params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut isSpot: bool = type_var.as_str() == Some("spot");
        let mut spotHash: Value = Value::Str("spot:private".into());
        let mut swapHash: Value = Value::Str("swap:private".into());
        let mut subscriptionHash: Value = (if isSpot { spotHash } else { swapHash });
        let mut spotMessageHash: Value = Value::Str("spot:mytrades".into());
        let mut swapMessageHash: Value = Value::Str("swap:mytrades".into());
        let mut messageHash: Value = (if isSpot { spotMessageHash } else { swapMessageHash });
        if (market != Value::Null) {
            messageHash = Value::Str(format!("{}{}", messageHash, Value::Str(format!("{}{}", Value::Str(":".into()), symbol).into())).into());
        }
        let mut uuid: Value = self.uuid(&[]);
        let mut baseUrl: Value = Value::Null;
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        if (type_var.as_str() == Some("swap")) {
            if (subType.as_str() == Some("inverse")) {
                panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" watchMyTrades is not supported for inverse swap markets yet".into()))));
            }
            baseUrl = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType, &[]);
        }  else {
            baseUrl = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), type_var, &[]);
            request = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("reqType".to_string(), Value::Str("sub".into()));
                    m.insert("dataType".to_string(), Value::Str("spot.executionReport".into()));
                m
            });
        }
        let mut url: Value = add(&Value::Str(format!("{}{}", baseUrl, Value::Str("?listenKey=".into())).into()), &self.options.as_map().and_then(|__m| __m.get("listenKey")).cloned().unwrap_or(Value::Null));
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid);
            m
        });
        let mut trades: Value = self.watch(url, messageHash, &[request, subscriptionHash, subscription]).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(trades, &[symbol, since, limit, Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bingx#watchBalance
 * @description query for balance and get the amount of funds available for trading or funds locked in orders
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Account%20Data/Subscription%20account%20balance%20push
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Account%20Data/Account%20balance%20and%20position%20update%20push
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Account%20Data/Account%20balance%20and%20position%20update%20push
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
 */
    pub async fn watch_balance(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut type_var: Value = Value::Null;
        let mut subType: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchBalance".into()), &[Value::Null, params.clone()]); type_var = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchBalance".into()), &[Value::Null, params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut isSpot: bool = type_var.as_str() == Some("spot");
        let mut spotSubHash: Value = Value::Str("spot:balance".into());
        let mut swapSubHash: Value = Value::Str("swap:private".into());
        let mut spotMessageHash: Value = Value::Str("spot:balance".into());
        let mut swapMessageHash: Value = Value::Str("swap:balance".into());
        let mut messageHash: Value = (if isSpot { spotMessageHash } else { swapMessageHash });
        let mut subscriptionHash: Value = (if isSpot { spotSubHash } else { swapSubHash });
        let mut request: Value = Value::Null;
        let mut baseUrl: Value = Value::Null;
        let mut uuid: Value = self.uuid(&[]);
        if (type_var.as_str() == Some("swap")) {
            if (subType.as_str() == Some("inverse")) {
                panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" watchBalance is not supported for inverse swap markets yet".into()))));
            }
            // swap balance updates are pushed automatically over the listenKey connection,
            // so we must not send a subscription message (an empty one is rejected with 80014)
            baseUrl = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType.clone(), &[]);
        }  else {
            baseUrl = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), type_var.clone(), &[]);
            request = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("dataType".to_string(), Value::Str("ACCOUNT_UPDATE".into()));
                m
            });
        }
        let mut url: Value = add(&Value::Str(format!("{}{}", baseUrl, Value::Str("?listenKey=".into())).into()), &self.options.as_map().and_then(|__m| __m.get("listenKey")).cloned().unwrap_or(Value::Null));
        let mut client: Value = self.client(&[url.clone()]);
        self.set_balance_cache(client.clone(), type_var.clone(), subType, subscriptionHash.clone(), params.clone());
        let mut fetchBalanceSnapshot: Value = Value::Null;
        let mut awaitBalanceSnapshot: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchBalance".into()), Value::Str("fetchBalanceSnapshot".into()), &[Value::Bool(true)]); fetchBalanceSnapshot = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchBalance".into()), Value::Str("awaitBalanceSnapshot".into()), &[Value::Bool(false)]); awaitBalanceSnapshot = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        if is_true(&fetchBalanceSnapshot) && is_true(&awaitBalanceSnapshot) {
            crate::exchange_stubs::ws_await_flight(&client.future(&[Value::Str(format!("{}{}", type_var, Value::Str(":fetchBalanceSnapshot".into())).into())])).await;
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid);
            m
        });
        return self.watch(url, messageHash, &[request, subscriptionHash, subscription]).await;

    Value::Null
}

    pub fn set_balance_cache(&mut self, mut client: Value, mut type_var: Value, mut subType: Value, mut subscriptionHash: Value, mut params: Value) {
        if (in_op(&get_value(&client, &Value::Str("subscriptions".into())), &subscriptionHash)) {
            return;
        }
        let mut fetchBalanceSnapshot: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchBalance".into()), Value::Str("fetchBalanceSnapshot".into()), &[Value::Bool(true)]); fetchBalanceSnapshot = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        if is_true(&fetchBalanceSnapshot) {
            let mut messageHash: Value = add(&type_var, &Value::Str(":fetchBalanceSnapshot".into()));
            if !(in_op(&get_value(&client, &Value::Str("futures".into())), &messageHash)) {
                client.future(&[messageHash.clone()]);
                self.spawn(&[Value::Str("load_balance_snapshot".into()).clone(), client.clone(), messageHash.clone(), type_var.clone(), subType]);
            }
        }  else {
            if let Value::Dict(__d) = &mut self.balance { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&type_var), Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})); }
        }
}

    pub async fn load_balance_snapshot(&mut self, mut client: Value, mut messageHash: Value, mut type_var: Value, mut subType: Value) -> Value {
        let mut response: Value = self.fetch_balance(&[Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), type_var.clone());
                m.insert("subType".to_string(), subType);
            m
        })]).await;
        let __ws_arg_5 = self.safe_dict(self.balance.clone(), type_var.clone(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})]);
        { let __be_tmp = self.extend(response, &[__ws_arg_5]); if let Value::Dict(__d) = &mut self.balance { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&type_var), __be_tmp); } }
        // don't remove the future from the .futures cache
        if (in_op(&get_value(&client, &Value::Str("futures".into())), &messageHash)) {
            let mut future: Value = get_value(&get_value(&client, &Value::Str("futures".into())), &messageHash);
            future.resolve(&[]);
            client.resolve(&[get_value(&self.balance, &type_var), add(&type_var, &Value::Str(":balance".into()))]);
        }

    Value::Null
}

/*
 * @method
 * @name bingx#watchPositions
 * @description watch all open positions
 * @see https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
 * @param {string[]|undefined} [symbols] list of unified market symbols
 * @param {int} [since] the earliest time in ms to fetch positions for
 * @param {int} [limit] the maximum number of position structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
 */
    pub async fn watch_positions(&mut self, optional_args: &[Value]) -> Value {
        let mut symbols = get_arg(optional_args, 0, Value::Null);
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("".into());
        symbols = self.market_symbols(&[symbols.clone()]);
        if (symbols != Value::Null) && !(self.is_empty(symbols.clone()).as_bool() == Some(true)) {
            market = self.get_market_from_symbols(&[symbols.clone()]);
            messageHash = Value::Str(format!("{}{}", Value::Str("::".into()), join(&symbols, &Value::Str(",".into()))).into());
        }
        let mut type_var: Value = Value::Null;
        let mut subType: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchPositions".into()), &[market.clone(), params.clone(), Value::Str("swap".into())]); type_var = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchPositions".into()), &[market, params.clone(), Value::Str("linear".into())]); subType = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        if (type_var.as_str() == Some("spot")) {
            panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" watchPositions is not supported for spot markets".into()))));
        }
        if (subType.as_str() == Some("inverse")) {
            panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" watchPositions is not supported for inverse swap markets yet".into()))));
        }
        let mut subscriptionHash: Value = Value::Str("swap:private".into());
        messageHash = Value::Str(format!("{}{}", Value::Str("swap:positions".into()), messageHash).into());
        let mut baseUrl: Value = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), subType, &[]);
        let mut url: Value = add(&Value::Str(format!("{}{}", baseUrl, Value::Str("?listenKey=".into())).into()), &self.options.as_map().and_then(|__m| __m.get("listenKey")).cloned().unwrap_or(Value::Null));
        let mut client: Value = self.client(&[url.clone()]);
        self.set_positions_cache(client.clone(), type_var.clone(), &[symbols.clone()]);
        let mut fetchPositionsSnapshot: Value = Value::Null;
        let mut awaitPositionsSnapshot: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchPositions".into()), Value::Str("fetchPositionsSnapshot".into()), &[Value::Bool(true)]); fetchPositionsSnapshot = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchPositions".into()), Value::Str("awaitPositionsSnapshot".into()), &[Value::Bool(false)]); awaitPositionsSnapshot = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut uuid: Value = self.uuid(&[]);
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid);
            m
        });
        if is_true(&fetchPositionsSnapshot) && is_true(&awaitPositionsSnapshot) && (self.positions.clone() == Value::Null) {
            let mut snapshot: Value = crate::exchange_stubs::ws_await_flight(&client.future(&[Value::Str(format!("{}{}", type_var, Value::Str(":fetchPositionsSnapshot".into())).into())])).await;
            return self.filter_by_symbols_since_limit(snapshot, &[symbols.clone(), since.clone(), limit.clone(), Value::Bool(true)]);
        }
        let mut newPositions: Value = self.watch(url, messageHash, &[Value::Null, subscriptionHash, subscription]).await;
        if is_true(&self.newUpdates) {
            return newPositions;
        }
        return self.filter_by_symbols_since_limit(self.positions.clone(), &[symbols, since, limit, Value::Bool(true)]);

    Value::Null
}

    pub fn set_positions_cache(&mut self, mut client: Value, mut type_var: Value, optional_args: &[Value]) {
        let mut symbols = get_arg(optional_args, 0, Value::Null);
        if (self.positions.clone() != Value::Null) {
            return;
        }
        let mut fetchPositionsSnapshot: Value = self.handle_option(Value::Str("watchPositions".into()), Value::Str("fetchPositionsSnapshot".into()), &[Value::Bool(true)]);
        if is_equal(&fetchPositionsSnapshot, &Value::Bool(true)) {
            let mut messageHash: Value = Value::Str(format!("{}{}", type_var, Value::Str(":fetchPositionsSnapshot".into())).into());
            if !(in_op(&get_value(&client, &Value::Str("futures".into())), &messageHash)) {
                client.future(&[messageHash.clone()]);
                self.spawn(&[Value::Str("load_positions_snapshot".into()).clone(), client.clone(), messageHash.clone(), type_var]);
            }
        }  else {
            self.positions = ArrayCacheBySymbolBySide::new(Value::Null);
        }
}

    pub async fn load_positions_snapshot(&mut self, mut client: Value, mut messageHash: Value, mut type_var: Value) -> Value {
        let mut positions: Value = self.fetch_positions(&[Value::Null, Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), type_var);
                m.insert("subType".to_string(), Value::Str("linear".into()));
            m
        })]).await;
        self.positions = ArrayCacheBySymbolBySide::new(Value::Null);
        let mut cache: Value = self.positions.clone();
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_93: bool = true;
            while { if !__for_first_93 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_93 = false; i.as_f64().unwrap_or(f64::NAN) < ((positions.len() as i64) as f64) } {
            let mut position: Value = positions.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut contracts: Value = self.safe_number_k(position.clone(), "contracts", &[Value::Int(0)]);
            if contracts.as_f64().unwrap_or(f64::NAN) > ((0i64) as f64) {
                cache.append(position);
            }
        }
        }
        // don't remove the future from the .futures cache
        if (in_op(&get_value(&client, &Value::Str("futures".into())), &messageHash)) {
            let mut future: Value = get_value(&get_value(&client, &Value::Str("futures".into())), &messageHash);
            future.resolve(&[cache.clone()]);
            client.resolve(&[cache, Value::Str("swap:positions".into())]);
        }

    Value::Null
}

    pub fn parse_ws_position(&self, mut position: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "s": "LINK-USDT",     // Symbol
        //         "pa": "5.000",        // Position Amount
        //         "ep": "11.2345",      // Entry Price
        //         "up": "0.5000",       // Unrealized PnL
        //         "mt": "isolated",     // Margin Type
        //         "iw": "50.00000000",  // Isolated Wallet
        //         "ps": "LONG"          // Position Side
        //     }
        //
        let mut marketId: Value = self.safe_string_k(position.clone(), "s", &[]);
        let mut contracts: Value = self.safe_string_k(position.clone(), "pa", &[]);
        let mut contractsAbs: Value = crate::precise::Precise::stringAbs(&contracts);
        let mut positionSide: Value = self.safe_string_lower_k(position.clone(), "ps", &[]);
        let mut hedged: Value = Value::Bool(true);
        if (positionSide.as_str() == Some("both")) {
            hedged = Value::Bool(false);
            if !is_true(&crate::precise::Precise::stringEq(&contracts, &Value::Str("0".into()))) {
                if is_true(&crate::precise::Precise::stringLt(&contracts, &Value::Str("0".into()))) {
                    positionSide = Value::Str("short".into());
                }  else {
                    positionSide = Value::Str("long".into());
                }
            }
        }
        let mut marginMode: Value = self.safe_string_k(position.clone(), "mt", &[]);
        let mut collateral: Value = (if (marginMode.as_str() == Some("isolated")) { self.safe_number_k(position.clone(), "iw", &[]) } else { Value::Null });
        return self.safe_position(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), position.clone());
        m.insert("id".to_string(), Value::Null);
        m.insert("symbol".to_string(), self.safe_symbol(marketId, &[Value::Null, Value::Null, Value::Str("swap".into())]));
        m.insert("notional".to_string(), Value::Null);
        m.insert("marginMode".to_string(), marginMode);
        m.insert("liquidationPrice".to_string(), Value::Null);
        m.insert("entryPrice".to_string(), self.safe_number_k(position.clone(), "ep", &[]));
        m.insert("unrealizedPnl".to_string(), self.safe_number_k(position, "up", &[]));
        m.insert("percentage".to_string(), Value::Null);
        m.insert("contracts".to_string(), self.parse_number(contractsAbs, &[]));
        m.insert("contractSize".to_string(), Value::Null);
        m.insert("markPrice".to_string(), Value::Null);
        m.insert("side".to_string(), positionSide);
        m.insert("hedged".to_string(), hedged);
        m.insert("timestamp".to_string(), Value::Null);
        m.insert("datetime".to_string(), Value::Null);
        m.insert("maintenanceMargin".to_string(), Value::Null);
        m.insert("maintenanceMarginPercentage".to_string(), Value::Null);
        m.insert("collateral".to_string(), collateral);
        m.insert("initialMargin".to_string(), Value::Null);
        m.insert("initialMarginPercentage".to_string(), Value::Null);
        m.insert("leverage".to_string(), Value::Null);
        m.insert("marginRatio".to_string(), Value::Null);
    m
}));

    Value::Null
}

    pub fn handle_positions(&mut self, mut client: Value, mut message: Value) {
        let __message_empty = indexmap::IndexMap::new();
        let message = message.as_map().unwrap_or(&__message_empty);
        //
        //     {
        //         "e": "ACCOUNT_UPDATE",
        //         "E": 1696244249320,
        //         "a": {
        //             "m": "ORDER",
        //             "B": [...],
        //             "P": [
        //                 {
        //                     "s": "LINK-USDT",
        //                     "pa": "5.000",
        //                     "ep": "11.2345",
        //                     "up": "0.5000",
        //                     "mt": "isolated",
        //                     "iw": "50.00000000",
        //                     "ps": "LONG"
        //                 }
        //             ]
        //         }
        //     }
        //
        if (self.positions.clone() == Value::Null) {
            self.positions = ArrayCacheBySymbolBySide::new(Value::Null);
        }
        let mut cache: Value = self.positions.clone();
        let mut data: Value = (match message.get("a") { Some(__v) if matches!(__v, Value::Dict(_)) => __v.clone(), _ => Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) });
        if !(matches!(&data, Value::Dict(__d) if __d.contains_key("P"))) {
            return;
        }
        let mut rawPositions: Value = self.safe_list_k(data, "P", &[Value::from(vec![])]);
        let mut newPositions: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_94: bool = true;
            while { if !__for_first_94 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_94 = false; i.as_f64().unwrap_or(f64::NAN) < ((rawPositions.len() as i64) as f64) } {
            let mut rawPosition: Value = rawPositions.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut position: Value = self.parse_ws_position(rawPosition, &[]);
            let mut symbol: Option<String> = self.safe_string_k(position.clone(), "symbol", &[]).as_str().map(str::to_owned);
            if (symbol.is_none()) {
                continue;
            }
            let mut timestamp: Value = (match message.get("E") { Some(Value::Int(__n)) => Value::Int(*__n), Some(Value::Float(__f)) => Value::Int(*__f as i64), Some(Value::Str(__s)) => match __s.parse::<i64>() { Ok(__n) => Value::Int(__n), Err(_) => match __s.parse::<f64>() { Ok(__f) if __f.is_finite() => Value::Int(__f as i64), _ => Value::Null } }, _ => Value::Null });
            add_element_to_object(&mut position, &Value::Str("timestamp".into()), timestamp.clone());
            add_element_to_object(&mut position, &Value::Str("datetime".into()), self.iso8601(timestamp));
            append_to_array(&mut newPositions, position.clone());
            cache.append(position);
        }
        }
        let mut messageHashes: Value = self.find_message_hashes(client.clone(), Value::Str("swap:positions::".into()));
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_95: bool = true;
            while { if !__for_first_95 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_95 = false; i.as_f64().unwrap_or(f64::NAN) < ((messageHashes.len() as i64) as f64) } {
            let mut messageHash: Value = messageHashes.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut parts: Value = split(&messageHash, &Value::Str("::".into()));
            let mut symbolsString: Value = parts.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null);
            let mut filteredSymbols: Value = split(&symbolsString, &Value::Str(",".into()));
            let mut positions: Value = self.filter_by_array(newPositions.clone(), Value::Str("symbol".into()), &[filteredSymbols, Value::Bool(false)]);
            if !(self.is_empty(positions.clone()).as_bool() == Some(true)) {
                client.resolve(&[positions, messageHash]);
            }
        }
        }
        client.resolve(&[newPositions, Value::Str("swap:positions".into())]);
}

    pub fn handle_error_message(&self, mut client: Value, mut message: Value) -> Value {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        // { code: 100400, msg: '', timestamp: 1696245808833 }
        //
        // {
        //     "code": 100500,
        //     "id": "9cd37d32-da98-440b-bd04-37e7dbcf51ad",
        //     "msg": '',
        //     "timestamp": 1696245842307
        // }
        let mut code: Value = (match __pro_message.get("code").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let _try_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
            if (code != Value::Null) {
                let mut feedback: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" ".into())).into()), json_stringify(&message)).into());
                self.throw_exactly_matched_exception(self.exceptions.as_map().and_then(|__m| __m.get("exact")).cloned().unwrap_or(Value::Null), code.clone(), feedback.clone());
            }
         #[allow(unreachable_code)] { Value::Null }}));
if let Err(_try_err) = _try_result { let e: Value = panic_to_value(_try_err);
            client.reject(&[e]);
        }
        return Value::Bool(true);

    Value::Null
}

    pub async fn keep_alive_listen_key(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut listenKey: Value = self.safe_string_k(self.options.clone(), "listenKey", &[]);
        if (listenKey == Value::Null) {
            return Value::Null;
        }
        let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
            self.parent.user_auth_private_put_user_data_stream(&[Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("listenKey".to_string(), listenKey.clone());
                m
            })]).await; // extend the expiry
         #[allow(unreachable_code)] { Value::Null }})).await;
if let Err(_try_err) = _try_result { let error: Value = panic_to_value(_try_err);
            let mut types: Value = Value::from(vec![Value::Str("spot".into()), Value::Str("linear".into()), Value::Str("inverse".into())]);
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_97: bool = true;
                while { if !__for_first_97 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_97 = false; i.as_f64().unwrap_or(f64::NAN) < ((types.len() as i64) as f64) } {
                let mut type_var: Value = types.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
                let mut baseUrl: Value = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), type_var, &[]);
                if (baseUrl == Value::Null) {
                    continue;
                }
                let mut url: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", baseUrl, Value::Str("?listenKey=".into())).into()), listenKey).into());
                let mut client: Value = self.client(&[url]);
                let mut messageHashes: Value = object_keys(&get_value(&client, &Value::Str("futures".into())));
                {
                                        let mut j: Value = Value::Int(0);
                    let mut __for_first_96: bool = true;
                    while { if !__for_first_96 { j = (match (&(j), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_96 = false; j.as_f64().unwrap_or(f64::NAN) < ((messageHashes.len() as i64) as f64) } {
                    let mut messageHash: Value = messageHashes.as_array().and_then(|__arr| match &j { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
                    client.reject(&[Value::from(error.clone()), messageHash]);
                }
                }
            }
            }
            if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("listenKey".into(), Value::Null); }
            if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("lastAuthenticatedTime".into(), Value::Int(0)); }
            return Value::Null;
        }
        // whether or not to schedule another listenKey keepAlive request
        let mut listenKeyRefreshRate: Value = self.safe_integer_k(self.options.clone(), "listenKeyRefreshRate", &[Value::Int(3600000)]);
        self.delay(listenKeyRefreshRate, &[Value::Str("keep_alive_listen_key".into()).clone(), params]).await;

    Value::Null
}

    pub async fn authenticate(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut time: Value = self.milliseconds();
        let mut lastAuthenticatedTime: Value = self.safe_integer_k(self.options.clone(), "lastAuthenticatedTime", &[Value::Int(0)]);
        let mut listenKeyRefreshRate: Value = self.safe_integer_k(self.options.clone(), "listenKeyRefreshRate", &[Value::Int(3600000)]); // 1 hour
        if (match (&(time), &(lastAuthenticatedTime)) { (Value::Int(x), Value::Int(y)) => Value::Int(x - y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 - *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x - *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x - y), _ => Value::Null }).as_f64().unwrap_or(f64::NAN) > listenKeyRefreshRate.as_f64().unwrap_or(f64::NAN) {
            // single-flight leader election on a never-dialed client, see
            // https://github.com/ccxt/ccxt/issues/29393: racing fetches mint
            // different keys and the key rides the private url, so losers
            // connect their watchers to an orphaned stream. client.futures is
            // the registry: client.future () is the atomic check-and-insert
            // and client.resolve () / client.reject () settle and remove the
            // entry under the same lock in every port
            let mut messageHash: Value = Value::Str("authenticate".into());
            let mut client: Value = self.client(&[Value::Str("authenticationFlights".into())]);
            if (in_op(&get_value(&client, &Value::Str("futures".into())), &messageHash)) {
                // a flight is already in progress - wake when the leader
                // settles it: the listenKey is then in the bucket
                crate::exchange_stubs::ws_await_flight(&client.future(&[messageHash.clone()])).await;
                return Value::Null;
            }
            // reusableFuture (), not future () - the two match in
            // js/py/php/cs/java, but go's Client.Future () yields a channel
            // that the trailing suspension point below would panic on
            let mut future: Value = client.reusable_future(messageHash.clone());
            let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
                let mut response: Value = self.parent.user_auth_private_post_user_data_stream(&[]).await;
                let mut listenKey: Value = self.safe_string_k(response, "listenKey", &[]);
                if (listenKey == Value::Null) {
                    panic!("{}", crate::exchange_errors::authentication_error(format!("{}{}", self.id.clone(), Value::Str(" authenticate() received an empty listenKey".into()))));
                }
                if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("listenKey".into(), listenKey.clone()); }
                if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("lastAuthenticatedTime".into(), time); }
                self.delay(listenKeyRefreshRate, &[Value::Str("keep_alive_listen_key".into()).clone(), params]).await;
                // settle the flight: client.resolve () removes the future from
                // client.futures and wakes every waiter
                client.resolve(&[listenKey, messageHash.clone()]);
             #[allow(unreachable_code)] { Value::Null }})).await;
if let Err(_try_err) = _try_result { let e: Value = panic_to_value(_try_err);
                // reject the flight - waiters throw and the next caller re-leads.
                // no rethrow here, the trailing suspension point rethrows to this
                // caller AND attaches the handler an alone leader needs
                client.reject(&[e, messageHash]);
            }
            crate::exchange_stubs::ws_await_flight(&future).await;
        }

    Value::Null
}

    pub async fn pong(&mut self, mut client: Value, mut message: Value) -> Value {
        let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
            if (message.as_str() == Some("Ping")) {
                client.send(&[Value::Str("Pong".into())]);
            }  else {
                let mut ping: Value = self.safe_string_k(message.clone(), "ping", &[]);
                let mut time: Value = self.safe_string_k(message.clone(), "time", &[]);
                client.send(&[Value::Map({
                    let mut m = indexmap::IndexMap::new();
                        m.insert("pong".to_string(), ping);
                        m.insert("time".to_string(), time);
                    m
                })]);
            }
         #[allow(unreachable_code)] { Value::Null }})).await;
if let Err(_try_err) = _try_result { let e: Value = panic_to_value(_try_err);
            let mut error = Value::from(crate::exchange_errors::network_error(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" pong failed with error ".into())).into()), self.exception_message(e, &[]))));
            client.reset(error);
        }

    Value::Null
}

    pub fn handle_order(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        //     {
        //         "code": 0,
        //         "dataType": "spot.executionReport",
        //         "data": {
        //            "e": "executionReport",
        //            "E": 1694680212947,
        //            "s": "LTC-USDT",
        //            "S": "BUY",
        //            "o": "LIMIT",
        //            "q": 0.1,
        //            "p": 50,
        //            "x": "NEW",
        //            "X": "PENDING",
        //            "i": 1702238305204043800,
        //            "l": 0,
        //            "z": 0,
        //            "L": 0,
        //            "n": 0,
        //            "N": "",
        //            "T": 0,
        //            "t": 0,
        //            "O": 1694680212676,
        //            "Z": 0,
        //            "Y": 0,
        //            "Q": 0,
        //            "m": false
        //         }
        //      }
        //
        //      {
        //         "code": 0,
        //         "dataType": "spot.executionReport",
        //         "data": {
        //           "e": "executionReport",
        //           "E": 1694681809302,
        //           "s": "LTC-USDT",
        //           "S": "BUY",
        //           "o": "MARKET",
        //           "q": 0,
        //           "p": 62.29,
        //           "x": "TRADE",
        //           "X": "FILLED",
        //           "i": "1702245001712369664",
        //           "l": 0.0802,
        //           "z": 0.0802,
        //           "L": 62.308,
        //           "n": -0.0000802,
        //           "N": "LTC",
        //           "T": 1694681809256,
        //           "t": 38259147,
        //           "O": 1694681809248,
        //           "Z": 4.9971016,
        //           "Y": 4.9971016,
        //           "Q": 5,
        //           "m": false
        //         }
        //       }
        // swap
        //    {
        //        "e": "ORDER_TRADE_UPDATE",
        //        "E": 1696843635475,
        //        "o": {
        //           "s": "LTC-USDT",
        //           "c": "",
        //           "i": "1711312357852147712",
        //           "S": "BUY",
        //           "o": "MARKET",
        //           "q": "0.10000000",
        //           "p": "64.35010000",
        //           "ap": "64.36000000",
        //           "x": "TRADE",
        //           "X": "FILLED",
        //           "N": "USDT",
        //           "n": "-0.00321800",
        //           "T": 0,
        //           "wt": "MARK_PRICE",
        //           "ps": "LONG",
        //           "rp": "0.00000000",
        //           "z": "0.10000000"
        //        }
        //    }
        //
        let mut isSpot: bool = matches!(&message, Value::Dict(__d) if __d.contains_key("dataType"));
        let mut data: Value = self.safe_dict2(message.clone(), Value::Str("data".into()), Value::Str("o".into()), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        if (self.orders.clone() == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "ordersLimit", &[Value::Int(1000)]);
            self.orders = ArrayCacheBySymbolById::new(limit);
        }
        let mut stored: Value = self.orders.clone();
        let mut parsedOrder: Value = self.parse_order(data, &[]);
        if !isSpot {
            // The envelope T is the order update time; o.T is the trade time.
            let mut updateTimestamp: Value = (match __pro_message.get("T").cloned() { Some(Value::Int(__n)) => Value::Int(__n), Some(Value::Float(__f)) => Value::Int(__f as i64), Some(Value::Str(__s)) if !__s.is_empty() => match __s.parse::<i64>() { Ok(__n) => Value::Int(__n), Err(_) => match __s.parse::<f64>() { Ok(__f) if __f.is_finite() => Value::Int(__f as i64), _ => Value::Null } }, _ => Value::Null });
            if (updateTimestamp != Value::Null) && (updateTimestamp.as_f64().unwrap_or(f64::NAN) > ((0i64) as f64)) {
                let mut orderId: Value = self.safe_string_k(parsedOrder.clone(), "id", &[]);
                if (orderId != Value::Null) {
                    {
                                                let mut i: Value = Value::Int(0);
                        let mut __for_first_98: bool = true;
                        while { if !__for_first_98 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_98 = false; i.as_f64().unwrap_or(f64::NAN) < get_array_length(&stored).as_f64().unwrap_or(f64::NAN) } {
                        let mut previousOrder: Value = get_value(&stored, &i);
                        let mut previousOrder: Value = get_value(&stored, &i);
                        if (is_equal(&crate::value::get_value_k(&previousOrder, "id"), &orderId)) && (is_equal(&crate::value::get_value_k(&previousOrder, "symbol"), &parsedOrder.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null))) {
                            let mut previousTimestamp: Value = self.safe_integer_k(previousOrder.clone(), "lastUpdateTimestamp", &[]);
                            if (previousTimestamp != Value::Null) && (updateTimestamp.as_f64().unwrap_or(f64::NAN) < previousTimestamp.as_f64().unwrap_or(f64::NAN)) {
                                return;
                            }
                            break;
                        }
                    }
                    }
                }
                add_element_to_object(&mut parsedOrder, &Value::Str("lastUpdateTimestamp".into()), updateTimestamp);
            }
        }
        stored.append(parsedOrder.clone());
        let mut symbol: Value = parsedOrder.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        let mut spotHash: Value = Value::Str("spot:order".into());
        let mut swapHash: Value = Value::Str("swap:order".into());
        let mut messageHash: Value = (if (isSpot) { spotHash } else { swapHash });
        client.resolve(&[stored.clone(), messageHash.clone()]);
        client.resolve(&[stored, Value::Str(format!("{}{}", Value::Str(format!("{}{}", messageHash, Value::Str(":".into())).into()), symbol).into())]);
}

    pub fn handle_my_trades(&mut self, mut client: Value, mut message: Value) {
        //
        //
        //      {
        //         "code": 0,
        //         "dataType": "spot.executionReport",
        //         "data": {
        //           "e": "executionReport",
        //           "E": 1694681809302,
        //           "s": "LTC-USDT",
        //           "S": "BUY",
        //           "o": "MARKET",
        //           "q": 0,
        //           "p": 62.29,
        //           "x": "TRADE",
        //           "X": "FILLED",
        //           "i": "1702245001712369664",
        //           "l": 0.0802,
        //           "z": 0.0802,
        //           "L": 62.308,
        //           "n": -0.0000802,
        //           "N": "LTC",
        //           "T": 1694681809256,
        //           "t": 38259147,
        //           "O": 1694681809248,
        //           "Z": 4.9971016,
        //           "Y": 4.9971016,
        //           "Q": 5,
        //           "m": false
        //         }
        //       }
        //
        //  swap
        //    {
        //        "e": "ORDER_TRADE_UPDATE",
        //        "E": 1696843635475,
        //        "o": {
        //           "s": "LTC-USDT",
        //           "c": "",
        //           "i": "1711312357852147712",
        //           "S": "BUY",
        //           "o": "MARKET",
        //           "q": "0.10000000",
        //           "p": "64.35010000",
        //           "ap": "64.36000000",
        //           "x": "TRADE",
        //           "X": "FILLED",
        //           "N": "USDT",
        //           "n": "-0.00321800",
        //           "T": 0,
        //           "wt": "MARK_PRICE",
        //           "ps": "LONG",
        //           "rp": "0.00000000",
        //           "z": "0.10000000"
        //        }
        //    }
        //
        let mut isSpot: bool = matches!(&message, Value::Dict(__d) if __d.contains_key("dataType"));
        let mut result: Value = self.safe_dict2(message.clone(), Value::Str("data".into()), Value::Str("o".into()), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut cachedTrades: Value = self.myTrades.clone();
        if (cachedTrades == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            cachedTrades = ArrayCacheBySymbolById::new(limit);
            self.myTrades = cachedTrades.clone();
        }
        let mut type_var: Value = (if isSpot { Value::Str("spot".into()) } else { Value::Str("swap".into()) });
        let mut marketId: Value = self.safe_string_k(result.clone(), "s", &[]);
        let mut market: Value = self.safe_market(&[marketId, Value::Null, Value::Str("-".into()), type_var]);
        let mut parsed: Value = self.parse_trade(result, &[market]);
        let mut symbol: Value = parsed.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        let mut spotHash: Value = Value::Str("spot:mytrades".into());
        let mut swapHash: Value = Value::Str("swap:mytrades".into());
        let mut messageHash: Value = (if isSpot { spotHash } else { swapHash });
        cachedTrades.append(parsed);
        client.resolve(&[cachedTrades.clone(), messageHash.clone()]);
        client.resolve(&[cachedTrades, Value::Str(format!("{}{}", Value::Str(format!("{}{}", messageHash, Value::Str(":".into())).into()), symbol).into())]);
}

    pub fn handle_balance(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        // spot
        //     {
        //         "e":"ACCOUNT_UPDATE",
        //         "E":1696242817000,
        //         "T":1696242817142,
        //         "a":{
        //            "B":[
        //               {
        //                  "a":"USDT",
        //                  "bc":"-1.00000000000000000000",
        //                  "cw":"86.59497382000000050000",
        //                  "wb":"86.59497382000000050000"
        //               }
        //            ],
        //            "m":"ASSET_TRANSFER"
        //         }
        //     }
        // swap
        //     {
        //         "e":"ACCOUNT_UPDATE",
        //         "E":1696244249320,
        //         "a":{
        //            "m":"WITHDRAW",
        //            "B":[
        //               {
        //                  "a":"USDT",
        //                  "wb":"49.81083984",
        //                  "cw":"49.81083984",
        //                  "bc":"-1.00000000"
        //               }
        //            ],
        //            "P":[
        //            ]
        //         }
        //     }
        //
        let mut a: Value = (match __pro_message.get("a").cloned() { Some(__v) if matches!(__v, Value::Dict(_)) => __v, _ => Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) });
        let mut data: Value = self.safe_list_k(a, "B", &[Value::from(vec![])]);
        let mut timestamp: Value = self.safe_integer2(message.clone(), Value::Str("T".into()), Value::Str("E".into()), &[]);
        let mut spotUrl: Value = self.safe_string(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), Value::Str("spot".into()), &[]);
        let mut isSpot: bool = (spotUrl != Value::Null) && (get_index_of(&get_value(&client, &Value::Str("url".into())), &spotUrl).as_f64() == Some(0.0));
        let mut type_var: Value = (if isSpot { Value::Str("spot".into()) } else { Value::Str("swap".into()) });
        if !(in_op(&self.balance, &type_var)) {
            if let Value::Dict(__d) = &mut self.balance { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&type_var), Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})); }
        }
        add_element_to_object(get_value_mut(&mut self.balance, &type_var), &Value::Str("info".into()), data.clone());
        add_element_to_object(get_value_mut(&mut self.balance, &type_var), &Value::Str("timestamp".into()), timestamp.clone());
        { let __be_tmp = self.iso8601(timestamp); add_element_to_object(get_value_mut(&mut self.balance, &type_var), &Value::Str("datetime".into()), __be_tmp); };
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_99: bool = true;
            while { if !__for_first_99 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_99 = false; i.as_f64().unwrap_or(f64::NAN) < ((data.len() as i64) as f64) } {
            let mut balance: Value = data.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut currencyId: Value = self.safe_string_k(balance.clone(), "a", &[]);
            let mut code: Value = self.safe_currency_code(currencyId, &[]);
            let mut account: Value = self.account();
            if let Value::Dict(__d) = &mut account { std::sync::Arc::make_mut(__d).insert("info".into(), balance.clone()); }
            if let Value::Dict(__d) = &mut account { std::sync::Arc::make_mut(__d).insert("used".into(), self.safe_string_k(balance.clone(), "lk", &[])); }
            if let Value::Dict(__d) = &mut account { std::sync::Arc::make_mut(__d).insert("free".into(), self.safe_string_k(balance.clone(), "wb", &[])); }
            if (type_var != Value::Null) && (code != Value::Null) {
                add_element_to_object(get_value_mut(&mut self.balance, &type_var), &code, account);
            }
        }
        }
        { let __be_tmp = self.safe_balance(get_value(&self.balance, &type_var)); if let Value::Dict(__d) = &mut self.balance { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&type_var), __be_tmp); } }
        client.resolve(&[get_value(&self.balance, &type_var), Value::Str(format!("{}{}", type_var, Value::Str(":balance".into())).into())]);
}

    pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
        if !(self.handle_error_message(client.clone(), message.clone()).as_bool() == Some(true)) {
            return;
        }
        // public subscriptions
        if (message.as_str() == Some("Ping")) || (in_op(&message, &Value::Str("ping".into()))) {
            self.spawn(&[Value::Str("pong".into()).clone(), client.clone(), message.clone()]);
            return;
        }
        let mut dataType: Value = self.safe_string_k(message.clone(), "dataType", &[Value::Str("".into())]);
        if Value::Int(dataType.as_str().and_then(|__s| __s.find("@depth")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64) {
            self.handle_order_book(client.clone(), message.clone());
            return;
        }
        if Value::Int(dataType.as_str().and_then(|__s| __s.find("@ticker")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64) {
            self.handle_ticker(client.clone(), message.clone());
            return;
        }
        if Value::Int(dataType.as_str().and_then(|__s| __s.find("@trade")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64) {
            self.handle_trades(client.clone(), message.clone());
            return;
        }
        if Value::Int(dataType.as_str().and_then(|__s| __s.find("@kline")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64) {
            self.handle_ohlcv(client.clone(), message.clone());
            return;
        }
        if Value::Int(dataType.as_str().and_then(|__s| __s.find("executionReport")).map(|__i| __i as i64).unwrap_or(-1)).as_f64().unwrap_or(f64::NAN) >= ((0i64) as f64) {
            let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut type_var: Value = self.safe_string_k(data.clone(), "x", &[]);
            if (type_var.as_str() == Some("TRADE")) {
                self.handle_my_trades(client.clone(), message.clone());
            }
            self.handle_order(client.clone(), message.clone());
            return;
        }
        let mut e: Option<String> = self.safe_string_k(message.clone(), "e", &[]).as_str().map(str::to_owned);
        if (e.as_deref() == Some("ACCOUNT_UPDATE")) {
            self.handle_balance(client.clone(), message.clone());
            self.handle_positions(client.clone(), message.clone());
        }
        if (e.as_deref() == Some("ORDER_TRADE_UPDATE")) {
            self.handle_order(client.clone(), message.clone());
            let mut data: Value = self.safe_dict_k(message.clone(), "o", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut type_var: Value = self.safe_string_k(data.clone(), "x", &[]);
            let mut status: Option<String> = self.safe_string_k(data, "X", &[]).as_str().map(str::to_owned);
            if (type_var.as_str() == Some("TRADE")) && (status.as_deref() == Some("FILLED")) {
                self.handle_my_trades(client.clone(), message.clone());
            }
        }
        let mut msgData: Value = self.safe_dict_k(message.clone(), "data", &[]);
        let mut msgEvent: Option<String> = self.safe_string_k(msgData, "e", &[]).as_str().map(str::to_owned);
        if (msgEvent.as_deref() == Some("24hTicker")) {
            self.handle_ticker(client.clone(), message.clone());
        }
        if (dataType.as_str() == Some("")) && (msgEvent.is_none()) && (e.is_none()) {
            self.handle_subscription_status(client, message.clone());
        }
}

    pub fn handle_subscription_status(&mut self, mut client: Value, mut message: Value) -> Value {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        //     {
        //         "code": 0,
        //         "id": "b6ed9cb4-f3d0-4641-ac3f-f59eb47a3abd",
        //         "msg": "SUCCESS",
        //         "timestamp": 1759225965363
        //     }
        //
        let mut id: Value = (match __pro_message.get("id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut subscriptionsById: Value = self.index_by(get_value(&client, &Value::Str("subscriptions".into())), Value::Str("id".into()));
        let mut subscription: Value = self.safe_dict(subscriptionsById, id.clone(), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut isUnSubMessage: Value = self.safe_bool_k(subscription.clone(), "unsubscribe", &[Value::Bool(false)]);
        if (isUnSubMessage.as_bool() == Some(true)) {
            self.handle_un_subscription(client, subscription);
        }
        return message;

    Value::Null
}

    pub fn handle_un_subscription(&mut self, mut client: Value, mut subscription: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &subscription { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        let mut messageHashes: Value = (match __pro_message.get("messageHashes").cloned() { Some(__v) if matches!(__v, Value::Arr(_)) => __v, _ => Value::from(vec![]) });
        let mut subMessageHashes: Value = (match __pro_message.get("subMessageHashes").cloned() { Some(__v) if matches!(__v, Value::Arr(_)) => __v, _ => Value::from(vec![]) });
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_100: bool = true;
            while { if !__for_first_100 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_100 = false; i.as_f64().unwrap_or(f64::NAN) < ((messageHashes.len() as i64) as f64) } {
            let mut unsubHash: Value = messageHashes.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut subHash: Value = subMessageHashes.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            self.clean_unsubscription(client.clone(), subHash, unsubHash, &[]);
        }
        }
        self.clean_cache(subscription);
}
}