binance_sdk/spot/websocket_api/

mod.rs

/*
 * Spot WebSocket API
 *
 * Access market data, manage accounts, and trade on Binance Spot.
 *
 * The version of the OpenAPI document: 1.0.0
 *
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */

#![allow(unused_imports)]
use serde::de::DeserializeOwned;
use serde_json::Value;
use std::{collections::BTreeMap, sync::Arc};

use crate::common::config::ConfigurationWebsocketApi;
use crate::common::models::WebsocketApiResponse;
use crate::common::utils::random_string;
use crate::common::websocket::{
    Subscription, WebsocketApi as WebsocketApiBase, WebsocketBase, WebsocketMessageSendOptions,
    WebsocketStream, create_stream_handler,
};
use crate::errors::WebsocketError;
use crate::models::{WebsocketEvent, WebsocketMode};

mod apis;
mod handle;
mod models;

pub use apis::*;
pub use handle::*;
pub use models::*;

const HAS_TIME_UNIT: bool = true;

#[derive(Clone)]
pub struct WebsocketApi {
    websocket_api_base: Arc<WebsocketApiBase>,

    account_api_client: AccountApiClient,
    auth_api_client: AuthApiClient,
    general_api_client: GeneralApiClient,
    market_api_client: MarketApiClient,
    trade_api_client: TradeApiClient,
    user_data_stream_api_client: UserDataStreamApiClient,
}

impl WebsocketApi {
    pub(crate) async fn connect(
        config: ConfigurationWebsocketApi,
        mode: Option<WebsocketMode>,
    ) -> anyhow::Result<Self> {
        let mut cfg = config;
        if let Some(m) = mode {
            cfg.mode = m;
        }
        if !HAS_TIME_UNIT {
            cfg.time_unit = None;
        }

        let websocket_api_base = WebsocketApiBase::new(cfg, vec![]);
        websocket_api_base.clone().connect().await?;

        Ok(Self {
            websocket_api_base: websocket_api_base.clone(),
            account_api_client: AccountApiClient::new(websocket_api_base.clone()),
            auth_api_client: AuthApiClient::new(websocket_api_base.clone()),
            general_api_client: GeneralApiClient::new(websocket_api_base.clone()),
            market_api_client: MarketApiClient::new(websocket_api_base.clone()),
            trade_api_client: TradeApiClient::new(websocket_api_base.clone()),
            user_data_stream_api_client: UserDataStreamApiClient::new(websocket_api_base.clone()),
        })
    }

    /// Subscribes to WebSocket events with a provided callback function.
    ///
    /// # Arguments
    ///
    /// * `callback` - A mutable function that will be called when a WebSocket event is received.
    ///   The callback takes a `WebsocketEvent` as its parameter.
    ///
    /// # Returns
    ///
    /// A `Subscription` that can be used to manage the event subscription.
    ///
    /// # Examples
    ///
    ///
    /// let subscription = `websocket_api.subscribe_on_ws_events(|event`| {
    ///     // Handle WebSocket event
    /// });
    ///
    pub fn subscribe_on_ws_events<F>(&self, callback: F) -> Subscription
    where
        F: FnMut(WebsocketEvent) + Send + 'static,
    {
        let base = Arc::clone(&self.websocket_api_base);
        base.common.events.subscribe(callback)
    }

    /// Unsubscribes from WebSocket events using the provided `Subscription`.
    ///
    /// # Arguments
    ///
    /// * `subscription` - The `Subscription` to unsubscribe from WebSocket events.
    ///
    /// # Examples
    ///
    ///
    /// let subscription = `websocket_api.subscribe_on_ws_events(|event`| {
    ///     // Handle WebSocket event
    /// });
    /// `websocket_api.unsubscribe_from_ws_events(subscription)`;
    ///
    pub fn unsubscribe_from_ws_events(&self, subscription: Subscription) {
        subscription.unsubscribe();
    }

    /// Disconnects the WebSocket connection.
    ///
    /// # Returns
    ///
    /// A `Result` indicating whether the disconnection was successful.
    /// Returns an error if the disconnection fails.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the connection fails.
    ///
    /// # Examples
    ///
    ///
    /// let result = `websocket_api.disconnect().await`;
    ///
    pub async fn disconnect(&self) -> anyhow::Result<()> {
        self.websocket_api_base
            .disconnect()
            .await
            .map_err(anyhow::Error::msg)
    }

    /// Sends a ping message to the WebSocket server to check the connection status.
    ///
    /// # Examples
    ///
    ///
    /// `websocket_api.ping_server().await`;
    ///
    ///
    /// This method sends a lightweight ping request to verify the WebSocket connection is still active.
    pub async fn ping_server(&self) {
        self.websocket_api_base.ping_server().await;
    }

    /// Checks if the WebSocket connection is currently active.
    ///
    /// # Returns
    ///
    /// A `bool` indicating whether the WebSocket connection is established and active.
    ///
    /// # Examples
    ///
    ///
    /// let `is_active` = `websocket_api.is_connected().await`;
    /// if `is_active` {
    ///     // WebSocket connection is active
    /// }
    ///
    ///
    /// This method provides a way to check the current status of the WebSocket connection.
    pub async fn is_connected(&self) -> bool {
        self.websocket_api_base.is_connected().await
    }

    /// Sends an unsigned WebSocket message with the specified method and payload.
    ///
    /// # Type Parameters
    ///
    /// * `R` - The response type to deserialize the message into.
    ///
    /// # Arguments
    ///
    /// * `method` - The WebSocket method to invoke.
    /// * `payload` - A map of key-value pairs representing the message payload.
    ///
    /// # Returns
    ///
    /// A `Result` containing the deserialized response or a `WebsocketError`.
    ///
    /// # Errors
    ///
    /// Returns a `WebsocketError` if the WebSocket connection fails or the response cannot be deserialized.
    ///
    /// # Examples
    ///
    ///
    /// let response = `websocket_api.send_message::`<ResponseType>("`method_name`", payload).await;
    ///
    pub async fn send_message<R: DeserializeOwned + Send + Sync + 'static>(
        &self,
        method: &str,
        payload: BTreeMap<String, Value>,
    ) -> Result<WebsocketApiResponse<R>, WebsocketError> {
        self.websocket_api_base
            .send_message::<R>(method, payload, WebsocketMessageSendOptions::new())
            .await?
            .into_iter()
            .next()
            .ok_or(WebsocketError::NoResponse)
    }

    /// Sends a signed WebSocket message with the specified method and payload.
    ///
    /// # Type Parameters
    ///
    /// * `R` - The response type to deserialize the message into.
    ///
    /// # Arguments
    ///
    /// * `method` - The WebSocket method to invoke.
    /// * `payload` - A map of key-value pairs representing the message payload.
    ///
    /// # Returns
    ///
    /// A `Result` containing the deserialized response or a `WebsocketError`.
    ///
    /// # Errors
    ///
    /// Returns a `WebsocketError` if the WebSocket connection fails or the response cannot be deserialized.
    ///
    /// # Examples
    ///
    ///
    /// let response = `websocket_api.send_signed_message::`<ResponseType>("`method_name`", payload).await;
    ///
    pub async fn send_signed_message<R: DeserializeOwned + Send + Sync + 'static>(
        &self,
        method: &str,
        payload: BTreeMap<String, Value>,
    ) -> Result<WebsocketApiResponse<R>, WebsocketError> {
        self.websocket_api_base
            .send_message::<R>(method, payload, WebsocketMessageSendOptions::new().signed())
            .await?
            .into_iter()
            .next()
            .ok_or(WebsocketError::NoResponse)
    }

    /// Account Commission Rates (`USER_DATA`)
    ///
    /// Get current account commission rates.
    ///
    /// Weight(IP): 20
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// # Arguments
    ///
    /// - `params`: [`AccountCommissionParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::AccountCommissionResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#account-commission).
    ///
    pub async fn account_commission(
        &self,
        params: AccountCommissionParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::AccountCommissionResponseResult>>> {
        self.account_api_client.account_commission(params).await
    }

    /// Unfilled Order Count (`USER_DATA`)
    ///
    /// Query your current unfilled order count for all intervals.
    ///
    /// Weight(IP): 40
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`AccountRateLimitsOrdersParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::AccountRateLimitsOrdersResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#account-rate-limits-orders).
    ///
    pub async fn account_rate_limits_orders(
        &self,
        params: AccountRateLimitsOrdersParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::AccountRateLimitsOrdersResponseResultInner>>>
    {
        self.account_api_client
            .account_rate_limits_orders(params)
            .await
    }

    /// Account information (`USER_DATA`)
    ///
    /// Query information about your account.
    ///
    /// Weight(IP): 20
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Memory => Database
    ///
    /// # Arguments
    ///
    /// - `params`: [`AccountStatusParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::AccountStatusResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#account-status).
    ///
    pub async fn account_status(
        &self,
        params: AccountStatusParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::AccountStatusResponseResult>>> {
        self.account_api_client.account_status(params).await
    }

    /// Account order list history (`USER_DATA`)
    ///
    /// Query information about all your order lists, filtered by time range.
    ///
    /// Weight(IP): 20
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// Notes:
    /// * If `startTime` and/or `endTime` are specified, `fromId` is ignored.
    /// Order lists are filtered by `transactionTime` of the last order list execution status update.
    /// * If `fromId` is specified, return order lists with order list ID >= `fromId`.
    /// * If no condition is specified, the most recent order lists are returned.
    /// * The time between `startTime` and `endTime` can't be longer than 24 hours.
    ///
    /// # Arguments
    ///
    /// - `params`: [`AllOrderListsParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::AllOrderListsResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#all-order-lists).
    ///
    pub async fn all_order_lists(
        &self,
        params: AllOrderListsParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::AllOrderListsResponseResultInner>>> {
        self.account_api_client.all_order_lists(params).await
    }

    /// Account order history (`USER_DATA`)
    ///
    /// Query information about all your orders – active, canceled, filled – filtered by time range.
    ///
    /// Weight(IP): 20
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// Notes:
    ///
    /// * If `startTime` and/or `endTime` are specified, `orderId` is ignored.
    ///
    /// Orders are filtered by `time` of the last execution status update.
    ///
    /// * If `orderId` is specified, return orders with order ID >= `orderId`.
    ///
    /// * If no condition is specified, the most recent orders are returned.
    ///
    /// * For some historical orders the `cummulativeQuoteQty` response field may be negative,
    /// meaning the data is not available at this time.
    ///
    /// * The time between `startTime` and `endTime` can't be longer than 24 hours.
    ///
    /// # Arguments
    ///
    /// - `params`: [`AllOrdersParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::AllOrdersResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#all-orders).
    ///
    pub async fn all_orders(
        &self,
        params: AllOrdersParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::AllOrdersResponseResultInner>>> {
        self.account_api_client.all_orders(params).await
    }

    /// Account allocations (`USER_DATA`)
    ///
    /// Retrieves allocations resulting from SOR order placement.
    ///
    /// Weight(IP): 20
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// Supported parameter combinations:
    ///
    /// Parameters                                  | Response |
    /// ------------------------------------------- | -------- |
    /// `symbol`                                    | allocations from oldest to newest |
    /// `symbol` + `startTime`                      | oldest allocations since `startTime` |
    /// `symbol` + `endTime`                        | newest allocations until `endTime` |
    /// `symbol` + `startTime` + `endTime`          | allocations within the time range |
    /// `symbol` + `fromAllocationId`               | allocations by allocation ID |
    /// `symbol` + `orderId`                        | allocations related to an order starting with oldest |
    /// `symbol` + `orderId` + `fromAllocationId`   | allocations related to an order by allocation ID |
    ///
    /// **Note:** The time between `startTime` and `endTime` can't be longer than 24 hours.
    ///
    /// # Arguments
    ///
    /// - `params`: [`MyAllocationsParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::MyAllocationsResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#my-allocations).
    ///
    pub async fn my_allocations(
        &self,
        params: MyAllocationsParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::MyAllocationsResponseResultInner>>> {
        self.account_api_client.my_allocations(params).await
    }

    /// Query Relevant Filters (`USER_DATA`)
    ///
    /// Retrieves the list of [filters](/products/spot/filters) relevant to an account on a given symbol. This is the only method
    /// that shows if an account has [`MAX_ASSET`](/products/spot/filters#max_asset) filters applied to it.
    ///
    /// Weight(IP): 40
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`MyFiltersParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<models::MyFiltersResponse>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#my-filters).
    ///
    pub async fn my_filters(
        &self,
        params: MyFiltersParams,
    ) -> anyhow::Result<WebsocketApiResponse<models::MyFiltersResponse>> {
        self.account_api_client.my_filters(params).await
    }

    /// Account prevented matches (`USER_DATA`)
    ///
    /// Displays the list of orders that were expired due to STP.
    ///
    /// These are the combinations supported:
    ///
    /// * `symbol` + `preventedMatchId`
    /// * `symbol` + `orderId`
    /// * `symbol` + `orderId` + `fromPreventedMatchId` (`limit` will default to 500)
    /// * `symbol` + `orderId` + `fromPreventedMatchId` + `limit`
    ///
    /// Weight: Case                            | Weight
    /// ----                            | -----
    /// If `symbol` is invalid          | 2
    /// Querying by `preventedMatchId`  | 2
    /// Querying by `orderId`           | 20
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// # Arguments
    ///
    /// - `params`: [`MyPreventedMatchesParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::MyPreventedMatchesResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#my-prevented-matches).
    ///
    pub async fn my_prevented_matches(
        &self,
        params: MyPreventedMatchesParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::MyPreventedMatchesResponseResultInner>>>
    {
        self.account_api_client.my_prevented_matches(params).await
    }

    /// Account trade history (`USER_DATA`)
    ///
    /// Query information about all your trades, filtered by time range.
    ///
    /// Weight: Condition| Weight|
    /// ---| ---
    /// |Without orderId|20|
    /// |With orderId|5|
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// Data Source: Memory => Database
    ///
    /// Notes:
    /// - If `fromId` is specified, return trades with trade ID >= `fromId`.
    /// - If `startTime` and/or `endTime` are specified, trades are filtered by execution time (`time`).
    /// - `fromId` cannot be used together with `startTime` and `endTime`.
    /// - If `orderId` is specified, only trades related to that order are returned.
    /// - `startTime` and `endTime` cannot be used together with `orderId`.
    /// - If no condition is specified, the most recent trades are returned.
    /// - The time between `startTime` and `endTime` can't be longer than 24 hours.
    ///
    /// # Arguments
    ///
    /// - `params`: [`MyTradesParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::MyTradesResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#my-trades).
    ///
    pub async fn my_trades(
        &self,
        params: MyTradesParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::MyTradesResponseResultInner>>> {
        self.account_api_client.my_trades(params).await
    }

    /// Current open Order lists (`USER_DATA`)
    ///
    /// Query execution status of all open order lists.
    ///
    /// If you need to continuously monitor order status updates, please consider using WebSocket Streams:
    ///
    /// * `userDataStream.subscribe` if on an authenticated session
    /// * `userDataStream.subscribe.signature` if subscribing through signature subscription
    ///
    /// Weight(IP): 6
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Memory -> Database
    ///
    /// # Arguments
    ///
    /// - `params`: [`OpenOrderListsStatusParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::OpenOrderListsStatusResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#open-order-lists-status).
    ///
    pub async fn open_order_lists_status(
        &self,
        params: OpenOrderListsStatusParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::OpenOrderListsStatusResponseResultInner>>>
    {
        self.account_api_client
            .open_order_lists_status(params)
            .await
    }

    /// Current open orders (`USER_DATA`)
    ///
    /// Query execution status of all open orders.
    ///
    /// If you need to continuously monitor order status updates, please consider using WebSocket Streams:
    ///
    /// * `userDataStream.subscribe` if on an authenticated session
    /// * `userDataStream.subscribe.signature` if subscribing through signature subscription
    ///
    /// Weight: | Parameter | Weight |
    /// | --------- | ------ |
    /// | `symbol`  |      6 |
    /// | none      |     80 |
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// Data Source: Memory => Database
    ///
    /// # Arguments
    ///
    /// - `params`: [`OpenOrdersStatusParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::OpenOrdersStatusResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#open-orders-status).
    ///
    pub async fn open_orders_status(
        &self,
        params: OpenOrdersStatusParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::OpenOrdersStatusResponseResultInner>>>
    {
        self.account_api_client.open_orders_status(params).await
    }

    /// Query Order Amendments (`USER_DATA`)
    ///
    /// Queries all amendments of a single order.
    ///
    /// Weight(IP): 4
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderAmendmentsParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::OrderAmendmentsResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#order-amendments).
    ///
    pub async fn order_amendments(
        &self,
        params: OrderAmendmentsParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::OrderAmendmentsResponseResultInner>>> {
        self.account_api_client.order_amendments(params).await
    }

    /// Query Order list (`USER_DATA`)
    ///
    /// Check execution status of an Order list.
    ///
    /// For execution status of individual orders, use `order.status`.
    ///
    /// Weight(IP): 4
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// Notes:
    ///
    /// * `origClientOrderId` refers to `listClientOrderId` of the order list itself.
    ///
    /// * If both `origClientOrderId` and `orderListId` parameters are specified,
    /// only `origClientOrderId` is used and `orderListId` is ignored.
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderListStatusParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderListStatusResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#order-list-status).
    ///
    pub async fn order_list_status(
        &self,
        params: OrderListStatusParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderListStatusResponseResult>>> {
        self.account_api_client.order_list_status(params).await
    }

    /// Query order (`USER_DATA`)
    ///
    /// Check execution status of an order.
    ///
    /// Weight(IP): 4
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Memory => Database
    ///
    /// Notes:
    ///
    /// * If both `orderId` and `origClientOrderId` are provided, the `orderId` is searched first, then the `origClientOrderId` from that result is checked against that order. If both conditions are not met the request will be rejected.
    ///
    /// * For some historical orders the `cummulativeQuoteQty` response field may be negative,
    /// meaning the data is not available at this time.
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderStatusParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderStatusResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/account#order-status).
    ///
    pub async fn order_status(
        &self,
        params: OrderStatusParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderStatusResponseResult>>> {
        self.account_api_client.order_status(params).await
    }

    /// Log in with API key (`USER_DATA`)
    ///
    /// Authenticate WebSocket connection using the provided API key.
    ///
    /// After calling `session.logon`, you can omit `apiKey` and `signature` parameters for future requests that require them.
    ///
    /// Note that only one API key can be authenticated.
    ///
    /// Calling `session.logon` multiple times changes the current authenticated API key.
    ///
    /// **Note:** Only Ed25519 keys are supported for this feature.
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: `USER_DATA`
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`SessionLogonParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::SessionLogonResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/auth#session-logon).
    ///
    pub async fn session_logon(
        &self,
        params: SessionLogonParams,
    ) -> anyhow::Result<Vec<WebsocketApiResponse<Box<models::SessionLogonResponseResult>>>> {
        self.auth_api_client.session_logon(params).await
    }

    /// Log out of the session
    ///
    /// Forget the API key previously authenticated. If the connection is not authenticated, this request does nothing.
    ///
    /// Note that the WebSocket connection stays open after `session.logout` request. You can continue using the connection, but now you will have to explicitly provide the `apiKey` and `signature` parameters where needed.
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`SessionLogoutParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::SessionLogoutResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/auth#session-logout).
    ///
    pub async fn session_logout(
        &self,
        params: SessionLogoutParams,
    ) -> anyhow::Result<Vec<WebsocketApiResponse<Box<models::SessionLogoutResponseResult>>>> {
        self.auth_api_client.session_logout(params).await
    }

    /// Query session status
    ///
    /// Query the status of the WebSocket connection,
    /// inspecting which API key (if any) is used to authorize requests.
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`SessionStatusParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::SessionStatusResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/auth#session-status).
    ///
    pub async fn session_status(
        &self,
        params: SessionStatusParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::SessionStatusResponseResult>>> {
        self.auth_api_client.session_status(params).await
    }

    /// Exchange information
    ///
    /// Query current exchange trading rules, rate limits, and symbol
    /// information.
    ///
    /// Weight(IP): 20
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// **Notes:**
    /// * If the value provided to `symbol` or `symbols` do not exist, the endpoint will throw an error saying the symbol is invalid.
    /// * All parameters are optional.
    /// * Only one of `symbol`, `symbols`, `permissions` parameters can be specified.
    /// * Without parameters, `exchangeInfo` displays all symbols with `["SPOT", "MARGIN", "LEVERAGED"]` permissions.
    /// * In order to list *all* active symbols on the exchange, you need to explicitly request all permissions.
    /// * `permissions` accepts either a list of permissions, or a single permission name. E.g. `"SPOT"`.
    ///
    /// **Examples of Symbol Permissions Interpretation from the Response:**
    ///
    /// * `[["A","B"]]` means you may place an order if your account has either permission "A" **or** permission "B".
    /// * `[["A"],["B"]]` means you can place an order if your account has permission "A" **and** permission "B".
    /// * `[["A"],["B","C"]]` means you can place an order if your account has permission "A" **and** permission "B" or permission "C". (Inclusive or is applied here, not exclusive or, so your account may have both permission "B" and permission "C".)
    ///
    /// # Arguments
    ///
    /// - `params`: [`ExchangeInfoParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<models::ExchangeInfoResponse>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/general#exchange-info).
    ///
    pub async fn exchange_info(
        &self,
        params: ExchangeInfoParams,
    ) -> anyhow::Result<WebsocketApiResponse<models::ExchangeInfoResponse>> {
        self.general_api_client.exchange_info(params).await
    }

    /// Query Execution Rules
    ///
    /// Query execution rules for symbols.
    ///
    /// Weight: Parameter | Weight
    /// --- | ---
    /// `symbol` | 2
    /// `symbols` | 2 for each `symbol`, capped at a max of 40
    /// `symbolStatus` | 40
    /// None | 40
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// **Note:** No combination of multiple parameters is allowed.
    ///
    /// # Arguments
    ///
    /// - `params`: [`ExecutionRulesParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::ExecutionRulesResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/general#execution-rules).
    ///
    pub async fn execution_rules(
        &self,
        params: ExecutionRulesParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::ExecutionRulesResponseResult>>> {
        self.general_api_client.execution_rules(params).await
    }

    /// Test connectivity
    ///
    /// Test connectivity to the WebSocket API.
    ///
    /// Note: You can use regular WebSocket ping frames to test connectivity as well, WebSocket API will respond with pong frames as soon as possible. ping request along with time is a safe way to test request-response handling in your application.
    ///
    /// Weight(IP): 1
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`PingParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<serde_json::Value>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/general#ping).
    ///
    pub async fn ping(
        &self,
        params: PingParams,
    ) -> anyhow::Result<WebsocketApiResponse<serde_json::Value>> {
        self.general_api_client.ping(params).await
    }

    /// Check server time
    ///
    /// Test connectivity to the WebSocket API and get the current server time.
    ///
    /// Weight(IP): 1
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`TimeParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::TimeResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/general#time).
    ///
    pub async fn time(
        &self,
        params: TimeParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::TimeResponseResult>>> {
        self.general_api_client.time(params).await
    }

    /// Current average price
    ///
    /// Get current average price for a symbol.
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`AvgPriceParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::AvgPriceResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#avg-price).
    ///
    pub async fn avg_price(
        &self,
        params: AvgPriceParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::AvgPriceResponseResult>>> {
        self.market_api_client.avg_price(params).await
    }

    /// Historical Block Trades
    ///
    /// Get block trades.
    ///
    /// Weight(IP): 25
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// - Data Source: Database
    ///
    /// # Arguments
    ///
    /// - `params`: [`BlockTradesHistoricalParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::BlockTradesHistoricalResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#block-trades-historical).
    ///
    pub async fn block_trades_historical(
        &self,
        params: BlockTradesHistoricalParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::BlockTradesHistoricalResponseResultInner>>>
    {
        self.market_api_client.block_trades_historical(params).await
    }

    /// Order book
    ///
    /// Get current order book.
    ///
    /// Note that this request returns limited market depth.
    ///
    /// If you need to continuously monitor order book updates, please consider using WebSocket Streams:
    /// * `<symbol>@depth<levels>`
    /// * `<symbol>@depth`
    ///
    /// You can use `depth` request together with `<symbol>@depth` streams to [maintain a local order book](/products/spot/web-socket-streams#how-to-manage-a-local-order-book-correctly).
    ///
    /// Weight: Adjusted based on the limit:
    ///
    /// |Limit|Request Weight
    /// ------|-------
    /// 1-100|  5
    /// 101-500| 25
    /// 501-1000| 50
    /// 1001-5000| 250
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`DepthParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::DepthResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#depth).
    ///
    pub async fn depth(
        &self,
        params: DepthParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::DepthResponseResult>>> {
        self.market_api_client.depth(params).await
    }

    /// Klines
    ///
    /// Get klines (candlestick bars).
    ///
    /// Klines are uniquely identified by their open & close time.
    ///
    /// If you need access to real-time kline updates, please consider using WebSocket Streams:
    /// * `<symbol>@kline_<interval>`
    ///
    /// If you need historical kline data, please consider using [data.binance.vision](https://github.com/binance/binance-public-data/#klines).
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// Supported kline intervals (case-sensitive):
    ///
    /// Interval  | `interval` value
    /// --------- | ----------------
    /// seconds   | `1s`
    /// minutes   | `1m`, `3m`, `5m`, `15m`, `30m`
    /// hours     | `1h`, `2h`, `4h`, `6h`, `8h`, `12h`
    /// days      | `1d`, `3d`
    /// weeks     | `1w`
    /// months    | `1M`
    ///
    /// **Notes:**
    ///
    /// * If `startTime` and `endTime` are not sent, the most recent klines are returned.
    /// * Supported values for `timeZone`:
    /// * Hours and minutes (e.g. `-1:00`, `05:45`)
    /// * Only hours (e.g. `0`, `8`, `4`)
    /// * Accepted range is strictly [-12:00 to +14:00] inclusive
    /// * If `timeZone` provided, kline intervals are interpreted in that timezone instead of UTC.
    /// * Note that `startTime` and `endTime` are always interpreted in UTC, regardless of `timeZone`.
    ///
    /// # Arguments
    ///
    /// - `params`: [`KlinesParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<Vec<models::KlinesResponseResultInnerInner>>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#klines).
    ///
    pub async fn klines(
        &self,
        params: KlinesParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<Vec<models::KlinesResponseResultInnerInner>>>>
    {
        self.market_api_client.klines(params).await
    }

    /// Query Reference Price
    ///
    /// Query Reference Price
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`ReferencePriceParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::ReferencePriceResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#reference-price).
    ///
    pub async fn reference_price(
        &self,
        params: ReferencePriceParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::ReferencePriceResponseResult>>> {
        self.market_api_client.reference_price(params).await
    }

    /// Query Reference Price Calculation
    ///
    /// Query Reference Price Calculation
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`ReferencePriceCalculationParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::ReferencePriceCalculationResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#reference-price-calculation).
    ///
    pub async fn reference_price_calculation(
        &self,
        params: ReferencePriceCalculationParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::ReferencePriceCalculationResponseResult>>>
    {
        self.market_api_client
            .reference_price_calculation(params)
            .await
    }

    /// Rolling window price change statistics
    ///
    /// Get rolling window price change statistics with a custom window.
    ///
    /// This request is similar to `ticker.24hr` but statistics are computed on demand using the arbitrary window you specify.
    ///
    /// **Note:** Window size precision is limited to 1 minute.
    /// While the `closeTime` is the current time of the request, `openTime` always start on a minute boundary.
    /// As such, the effective window might be up to 59999 ms wider than the requested `windowSize`.
    ///
    /// <details>
    /// <summary>Window computation example</summary>
    ///
    /// For example, a request for `"windowSize": "7d"` might result in the following window:
    ///
    /// ```javascript
    /// {
    /// "openTime": 1659580020000,
    /// "closeTime": 1660184865291
    /// }
    /// ```
    ///
    /// Time of the request – `closeTime` – is 1660184865291 (August 11, 2022 02:27:45.291).
    /// Requested window size should put the `openTime` 7 days before that – August 4, 02:27:45.291 –
    /// but due to limited precision it ends up a bit earlier: 1659580020000 (August 4, 2022 02:27:00),
    /// exactly at the start of a minute.
    /// </details>
    ///
    /// If you need to continuously monitor trading statistics, please consider using WebSocket Streams:
    /// * `<symbol>@ticker_<window_size>` or `!ticker_<window-size>@arr`
    ///
    /// Weight: Adjusted based on the number of requested symbols:
    ///
    /// | Symbols | Weight |
    /// |:-------:|:------:|
    /// |    1–50 | 4 per symbol |
    /// |  51–100 |    200 |
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// Supported window sizes:
    ///
    /// Unit    | `windowSize` value
    /// ------- | ------------------
    /// minutes | `1m`, `2m` ... `59m`
    /// hours   | `1h`, `2h` ... `23h`
    /// days    | `1d`, `2d` ... `7d`
    ///
    /// Notes:
    ///
    /// * Either `symbol` or `symbols` must be specified.
    ///
    /// * Maximum number of symbols in one request: 200.
    ///
    /// * Window size units cannot be combined.
    /// E.g., <code>1d 2h</code> is not supported.
    ///
    /// # Arguments
    ///
    /// - `params`: [`TickerParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<models::TickerResponse>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#ticker).
    ///
    pub async fn ticker(
        &self,
        params: TickerParams,
    ) -> anyhow::Result<WebsocketApiResponse<models::TickerResponse>> {
        self.market_api_client.ticker(params).await
    }

    /// 24hr ticker price change statistics
    ///
    /// Get 24-hour rolling window price change statistics.
    ///
    /// If you need to continuously monitor trading statistics, please consider using WebSocket Streams:
    ///
    /// * `<symbol>@ticker` or `!ticker@arr`
    ///
    /// * `<symbol>@miniTicker` or `!miniTicker@arr`
    ///
    /// If you need different window sizes,
    ///
    /// use the `ticker` request.
    ///
    /// Weight: Adjusted based on the number of requested symbols:
    ///
    /// |Parameter|Symbols Provided|Weight|
    /// |---|---|---|
    /// |symbol| 1 |2|
    /// | |omitted| 80|
    /// |symbols| 1-20 |2|
    /// | | 21-100 |40|
    /// | | 101+ |80|
    /// | |omitted| 80|
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// Notes:
    ///
    /// * `symbol` and `symbols` cannot be used together.
    ///
    /// * If no symbol is specified, returns information about all symbols currently trading on the exchange.
    ///
    /// # Arguments
    ///
    /// - `params`: [`Ticker24hrParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<models::Ticker24hrResponse>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#ticker24hr).
    ///
    pub async fn ticker24hr(
        &self,
        params: Ticker24hrParams,
    ) -> anyhow::Result<WebsocketApiResponse<models::Ticker24hrResponse>> {
        self.market_api_client.ticker24hr(params).await
    }

    /// Symbol order book ticker
    ///
    /// Get the current best price and quantity on the order book.
    ///
    /// If you need access to real-time order book ticker updates, please
    /// consider using WebSocket Streams:
    ///
    /// * `<symbol>@bookTicker`
    ///
    /// Weight: Adjusted based on the number of requested symbols:
    ///
    /// |Parameter|Symbols Provided|Weight|
    /// |---|---|---|
    /// |symbol| 1 |2|
    /// | |omitted| 4|
    /// |symbols| Any |4|
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// Notes:
    ///
    /// * `symbol` and `symbols` cannot be used together.
    ///
    /// * If no symbol is specified, returns information about all symbols currently trading on the exchange.
    ///
    /// # Arguments
    ///
    /// - `params`: [`TickerBookParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<models::TickerBookResponse>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#ticker-book).
    ///
    pub async fn ticker_book(
        &self,
        params: TickerBookParams,
    ) -> anyhow::Result<WebsocketApiResponse<models::TickerBookResponse>> {
        self.market_api_client.ticker_book(params).await
    }

    /// Symbol price ticker
    ///
    /// Get the latest market price for a symbol.
    ///
    /// If you need access to real-time price updates, please consider using
    /// WebSocket Streams:
    ///
    /// * `<symbol>@aggTrade`
    ///
    /// * `<symbol>@trade`
    ///
    /// Weight: Adjusted based on the number of requested symbols:
    ///
    /// |Parameter|Symbols Provided|Weight|
    /// |---|---|---|
    /// |symbol| 1 |2|
    /// | |omitted| 4|
    /// |symbols| Any |4|
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// Notes:
    ///
    /// * `symbol` and `symbols` cannot be used together.
    ///
    /// * If no symbol is specified, returns information about all symbols currently trading on the exchange.
    ///
    /// # Arguments
    ///
    /// - `params`: [`TickerPriceParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<models::TickerPriceResponse>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#ticker-price).
    ///
    pub async fn ticker_price(
        &self,
        params: TickerPriceParams,
    ) -> anyhow::Result<WebsocketApiResponse<models::TickerPriceResponse>> {
        self.market_api_client.ticker_price(params).await
    }

    /// Trading Day Ticker
    ///
    /// Price change statistics for a trading day.
    ///
    /// Weight: 4 for each requested symbol regardless of windowSize. The weight for this request will cap at 200 once the number of symbols in the request is more than 50.
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// **Notes:**
    ///
    /// * Supported values for `timeZone`:
    /// * Hours and minutes (e.g. `-1:00`, `05:45`)
    /// * Only hours (e.g. `0`, `8`, `4`)
    ///
    ///
    /// # Arguments
    ///
    /// - `params`: [`TickerTradingDayParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::TickerTradingDayResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#ticker-trading-day).
    ///
    pub async fn ticker_trading_day(
        &self,
        params: TickerTradingDayParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::TickerTradingDayResponseResultInner>>>
    {
        self.market_api_client.ticker_trading_day(params).await
    }

    /// Aggregate trades
    ///
    /// Get aggregate trades.
    ///
    /// An *aggregate trade* (aggtrade) represents one or more individual
    /// trades.
    ///
    /// Trades that fill at the same time, from the same taker order, with the
    /// same price –
    ///
    /// those trades are collected into an aggregate trade with total quantity
    /// of the individual trades.
    ///
    /// If you need access to real-time trading activity, please consider using
    /// WebSocket Streams:
    ///
    /// * `<symbol>@aggTrade`
    ///
    /// If you need historical aggregate trade data, please consider using [data.binance.vision](https://github.com/binance/binance-public-data/#aggtrades).
    ///
    /// Weight(IP): 4
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// - If `fromId` is specified, return aggtrades with aggregate trade ID >= `fromId`. Use `fromId` and `limit` to page through all aggtrades.
    /// - If `startTime` and/or `endTime` are specified, aggtrades are filtered by execution time (`T`). `fromId` cannot be used together with `startTime` and `endTime`.
    /// - If no condition is specified, the most recent aggregate trades are returned.
    ///
    /// # Arguments
    ///
    /// - `params`: [`TradesAggregateParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::TradesAggregateResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#trades-aggregate).
    ///
    pub async fn trades_aggregate(
        &self,
        params: TradesAggregateParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::TradesAggregateResponseResultInner>>> {
        self.market_api_client.trades_aggregate(params).await
    }

    /// Historical trades
    ///
    /// Get historical trades.
    ///
    /// Weight(IP): 25
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// Notes:
    ///
    /// * If `fromId` is not specified, the most recent trades are returned.
    ///
    /// # Arguments
    ///
    /// - `params`: [`TradesHistoricalParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::TradesHistoricalResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#trades-historical).
    ///
    pub async fn trades_historical(
        &self,
        params: TradesHistoricalParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::TradesHistoricalResponseResultInner>>>
    {
        self.market_api_client.trades_historical(params).await
    }

    /// Recent trades
    ///
    /// Get recent trades.
    ///
    /// If you need access to real-time trading activity, please consider using
    /// WebSocket Streams:
    ///
    /// * `<symbol>@trade`
    ///
    /// Weight(IP): 25
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`TradesRecentParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::TradesRecentResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#trades-recent).
    ///
    pub async fn trades_recent(
        &self,
        params: TradesRecentParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::TradesRecentResponseResultInner>>> {
        self.market_api_client.trades_recent(params).await
    }

    /// UI Klines
    ///
    /// Get klines (candlestick bars) optimized for presentation.
    ///
    /// This request is similar to `klines`, having the same parameters and response. `uiKlines` return modified kline data, optimized for presentation of candlestick charts.
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Database
    ///
    /// - If `startTime` and `endTime` are not sent, the most recent klines are returned.
    /// - Supported values for `timeZone`:
    /// - Hours and minutes (e.g. `-1:00`, `05:45`)
    /// - Only hours (e.g. `0`, `8`, `4`)
    /// - Accepted range is strictly [-12:00 to +14:00] inclusive
    /// - If `timeZone` provided, kline intervals are interpreted in that timezone instead of UTC.
    /// - Note that `startTime` and `endTime` are always interpreted in UTC, regardless of `timeZone`.
    ///
    /// # Arguments
    ///
    /// - `params`: [`UiKlinesParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<Vec<models::KlinesResponseResultInnerInner>>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/market#ui-klines).
    ///
    pub async fn ui_klines(
        &self,
        params: UiKlinesParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<Vec<models::KlinesResponseResultInnerInner>>>>
    {
        self.market_api_client.ui_klines(params).await
    }

    /// Cancel open orders (TRADE)
    ///
    /// Cancel all open orders on a symbol.
    /// This includes orders that are part of an order list.
    ///
    /// Weight(IP): 1
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// # Arguments
    ///
    /// - `params`: [`OpenOrdersCancelAllParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::OpenOrdersCancelAllResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#open-orders-cancel-all).
    ///
    pub async fn open_orders_cancel_all(
        &self,
        params: OpenOrdersCancelAllParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::OpenOrdersCancelAllResponseResultInner>>>
    {
        self.trade_api_client.open_orders_cancel_all(params).await
    }

    /// Order Amend Keep Priority (TRADE)
    ///
    /// Reduce the quantity of an existing open order.
    ///
    /// This adds 0 orders to the `EXCHANGE_MAX_ORDERS` filter and the `MAX_NUM_ORDERS` filter.
    ///
    /// Read [Order Amend Keep Priority FAQ](/products/spot/faqs/order_amend_keep_priority) to learn more.
    ///
    /// Weight(IP): 4
    ///
    /// Unfilled Order Count: 0
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderAmendKeepPriorityParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderAmendKeepPriorityResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-amend-keep-priority).
    ///
    pub async fn order_amend_keep_priority(
        &self,
        params: OrderAmendKeepPriorityParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderAmendKeepPriorityResponseResult>>>
    {
        self.trade_api_client
            .order_amend_keep_priority(params)
            .await
    }

    /// Cancel order (TRADE)
    ///
    /// Cancel an active order.
    ///
    /// Weight(IP): 1
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// Notes:
    ///
    /// * If both `orderId` and `origClientOrderId` parameters are provided, the `orderId` is searched first, then the `origClientOrderId` from that result is checked against that order. If both conditions are not met the request will be rejected.
    ///
    /// * `newClientOrderId` will replace `clientOrderId` of the canceled order, freeing it up for new orders.
    ///
    /// * If you cancel an order that is a part of an order list, the entire order list is canceled.
    ///
    /// * The performance for canceling an order (single cancel or as part of a cancel-replace) is always better when only `orderId` is sent. Sending `origClientOrderId` or both `orderId` + `origClientOrderId` will be slower.
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderCancelParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderCancelResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-cancel).
    ///
    pub async fn order_cancel(
        &self,
        params: OrderCancelParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderCancelResponseResult>>> {
        self.trade_api_client.order_cancel(params).await
    }

    /// Cancel and replace order (TRADE)
    ///
    /// * Cancel an existing order and immediately place a new order instead of the canceled one.
    /// * A new order that was not attempted (i.e. when `newOrderResult: NOT_ATTEMPTED`), will still increase the unfilled order count by 1.
    /// * You can only cancel an individual order from an orderList using this method, but the result is the same as canceling the entire orderList.not attempted (i.e. when `newOrderResult: NOT_ATTEMPTED`), will still increase the unfilled order count by 1.
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 1
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// Similar to the [`order.place`](#order-place) request,
    /// additional mandatory parameters (*) are determined by the new order `type`.
    ///
    /// Available `cancelReplaceMode` options:
    ///
    /// * `STOP_ON_FAILURE` – if cancellation request fails, new order placement will not be attempted.
    /// * `ALLOW_FAILURE` – new order placement will be attempted even if the cancel request fails.
    ///
    /// <table>
    /// <thead>
    /// <tr>
    /// <th colspan=3 align=left>Request</th>
    /// <th colspan=3 align=left>Response</th>
    /// </tr>
    /// <tr>
    /// <th><code>cancelReplaceMode</code></th>
    /// <th><code>orderRateLimitExceededMode</code></th>
    /// <th>Unfilled Order Count</th>
    /// <th><code>cancelResult</code></th>
    /// <th><code>newOrderResult</code></th>
    /// <th><code>status</code></th>
    /// </tr>
    /// </thead>
    /// <tbody>
    /// <tr>
    /// <td rowspan="11"><code>STOP_ON_FAILURE</code></td>
    /// <td rowspan="6"><code>DO_NOTHING</code></td>
    /// <td rowspan="3">Within Limits</td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right><code>200</code></td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>➖ <code>NOT_ATTEMPTED</code></td>
    /// <td align=right><code>400</code></td>
    /// </tr>
    /// <tr>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>409</code></td>
    /// </tr>
    /// <tr>
    /// <td rowspan="3">Exceeds Limits</td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right>N/A</td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>➖ <code>NOT_ATTEMPTED</code></td>
    /// <td align=right>N/A</td>
    /// </tr>
    /// <tr>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right>N/A</td>
    /// </tr>
    /// <tr>
    /// <td rowspan="5"><code>CANCEL_ONLY</code></td>
    /// <td rowspan="3">Within Limits</td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right><code>200</code></td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>➖ <code>NOT_ATTEMPTED</code></td>
    /// <td align=right><code>400</code></td>
    /// </tr>
    /// <tr>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>409</code></td>
    /// </tr>
    /// <tr>
    /// <td rowspan="2">Exceeds Limits</td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>➖ <code>NOT_ATTEMPTED</code></td>
    /// <td align=right><code>429</code></td>
    /// </tr>
    /// <tr>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>429</code></td>
    /// </tr>
    /// <tr>
    /// <td rowspan="16"><code>ALLOW_FAILURE</code></td>
    /// <td rowspan="8"><code>DO_NOTHING</code></td>
    /// <td rowspan="4">Within Limits</td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right><code>200</code></td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>400</code></td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right><code>409</code></td>
    /// </tr>
    /// <tr>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>409</code></td>
    /// </tr>
    /// <tr>
    /// <td rowspan="4">Exceeds Limits</td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right>N/A</td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right>N/A</td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right>N/A</td>
    /// </tr>
    /// <tr>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right>N/A</td>
    /// </tr>
    /// <tr>
    /// <td rowspan="8"><CODE>CANCEL_ONLY</CODE></td>
    /// <td rowspan="4">Within Limits</td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right><code>200</code></td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>400</code></td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right><code>409</code></td>
    /// </tr>
    /// <tr>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>409</code></td>
    /// </tr>
    /// <tr>
    /// <td rowspan="4">Exceeds Limits</td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right><code>200</code></td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>400</code></td>
    /// </tr>
    /// <tr>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td align=right>N/A</td>
    /// </tr>
    /// <tr>
    /// <td>✅ <code>SUCCESS</code></td>
    /// <td>❌ <code>FAILURE</code></td>
    /// <td align=right><code>409</code></td>
    /// </tr>
    /// </tbody>
    /// </table>
    ///
    /// Notes:
    ///
    /// * If both `cancelOrderId` and `cancelOrigClientOrderId` parameters are provided, the `cancelOrderId` is searched first, then the `cancelOrigClientOrderId` from that result is checked against that order. If both conditions are not met the request will be rejected.
    ///
    /// * `cancelNewClientOrderId` will replace `clientOrderId` of the canceled order, freeing it up for new orders.
    ///
    /// * `newClientOrderId` specifies `clientOrderId` value for the placed order.
    ///
    /// A new order with the same `clientOrderId` is accepted only when the previous one is filled or expired.
    ///
    /// The new order can reuse old `clientOrderId` of the canceled order.
    ///
    /// * This cancel-replace operation is **not transactional**.
    ///
    /// If one operation succeeds but the other one fails, the successful operation is still executed.
    ///
    /// For example, in `STOP_ON_FAILURE` mode, if the new order placement fails, the old order is still canceled.
    ///
    /// * Filters and order count limits are evaluated before cancellation and order placement occurs.
    ///
    /// * If new order placement is not attempted, your order count is still incremented.
    ///
    /// * Like [`order.cancel`](#order-cancel), if you cancel an individual order from an order list, the entire order list is canceled.
    ///
    /// * The performance for canceling an order (single cancel or as part of a cancel-replace) is always better when only `orderId` is sent. Sending `origClientOrderId` or both `orderId` + `origClientOrderId` will be slower.
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderCancelReplaceParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderCancelReplaceResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-cancel-replace).
    ///
    pub async fn order_cancel_replace(
        &self,
        params: OrderCancelReplaceParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderCancelReplaceResponseResult>>> {
        self.trade_api_client.order_cancel_replace(params).await
    }

    /// Cancel Order list (TRADE)
    ///
    /// Cancel an active order list.
    ///
    /// Weight(IP): 1
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// Notes:
    ///
    /// * If both `orderListId` and `listClientOrderId` parameters are provided, the `orderListId` is searched first, then the `listClientOrderId` from that result is checked against that order. If both conditions are not met the request will be rejected.
    ///
    /// * Canceling an individual order with [`order.cancel`](#order-cancel) will cancel the entire order list as well.
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderListCancelParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderListCancelResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-list-cancel).
    ///
    pub async fn order_list_cancel(
        &self,
        params: OrderListCancelParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderListCancelResponseResult>>> {
        self.trade_api_client.order_list_cancel(params).await
    }

    /// Place new OCO - Deprecated (TRADE)
    ///
    /// Send in a new one-cancels-the-other (OCO) pair:
    /// `LIMIT_MAKER` + `STOP_LOSS`/`STOP_LOSS_LIMIT` orders (called *legs*),
    /// where activation of one order immediately cancels the other.
    ///
    /// This adds 1 order to `EXCHANGE_MAX_ORDERS` filter and the `MAX_NUM_ORDERS` filter
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 1
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// Notes:
    ///
    /// * `listClientOrderId` parameter specifies `listClientOrderId` for the OCO pair.
    ///
    /// A new OCO with the same `listClientOrderId` is accepted only when the previous one is filled or completely expired.
    ///
    /// `listClientOrderId` is distinct from `clientOrderId` of individual orders.
    ///
    /// * `limitClientOrderId` and `stopClientOrderId` specify `clientOrderId` values for both legs of the OCO.
    ///
    /// A new order with the same `clientOrderId` is accepted only when the previous one is filled or expired.
    ///
    /// * Price restrictions on the legs:
    ///
    /// | `side` | Price relation |
    /// | ------ | -------------- |
    /// | `BUY`  | `price` < market price < `stopPrice` |
    /// | `SELL` | `price` > market price > `stopPrice` |
    ///
    /// * Both legs have the same `quantity`.
    ///
    /// However, you can set different iceberg quantity for individual legs.
    ///
    /// If `stopIcebergQty` is used, `stopLimitTimeInForce` must be `GTC`.
    ///
    /// * `trailingDelta` applies only to the `STOP_LOSS`/`STOP_LOSS_LIMIT` leg of the OCO.
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderListPlaceParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderListPlaceResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-list-place).
    ///
    /// # Deprecation
    ///
    /// **Deprecated:** This method may be removed in a future version.
    #[deprecated]
    pub async fn order_list_place(
        &self,
        params: OrderListPlaceParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderListPlaceResponseResult>>> {
        self.trade_api_client.order_list_place(params).await
    }

    /// Place new Order list - OCO (TRADE)
    ///
    /// Send in an one-cancels-the-other (OCO) pair, where activation of one order immediately cancels the other.
    ///
    /// * An OCO has 2 orders called the **above order** and **below order**.
    ///
    /// * One of the orders must be a `LIMIT_MAKER/TAKE_PROFIT/TAKE_PROFIT_LIMIT` order and the other must be
    /// `STOP_LOSS` or `STOP_LOSS_LIMIT` order.
    ///
    /// * Price restrictions:
    /// * If the OCO is on the `SELL` side:
    /// * `LIMIT_MAKER/TAKE_PROFIT_LIMIT` `price` > Last Traded Price > `STOP_LOSS/STOP_LOSS_LIMIT`
    /// `stopPrice`
    /// * `TAKE_PROFIT stopPrice` > Last Traded Price > `STOP_LOSS/STOP_LOSS_LIMIT
    /// stopPrice`
    /// * If the OCO is on the `BUY` side:
    /// * `LIMIT_MAKER` `price` < Last Traded Price < `STOP_LOSS/STOP_LOSS_LIMIT` `stopPrice`
    /// * `TAKE_PROFIT stopPrice` > Last Traded Price > `STOP_LOSS/STOP_LOSS_LIMIT stopPrice`
    /// *  OCOs add **2 orders** to the `EXCHANGE_MAX_ORDERS` filter and `MAX_NUM_ORDERS` filter.
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 2
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderListPlaceOcoParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderListPlaceOcoResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-list-place-oco).
    ///
    pub async fn order_list_place_oco(
        &self,
        params: OrderListPlaceOcoParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderListPlaceOcoResponseResult>>> {
        self.trade_api_client.order_list_place_oco(params).await
    }

    /// OPO (TRADE)
    ///
    /// Place an [OPO](/products/spot/faqs/opo).
    ///
    /// * OPOs add 2 orders to the `EXCHANGE_MAX_NUM_ORDERS` filter and `MAX_NUM_ORDERS` filter.
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 2
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderListPlaceOpoParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderListPlaceOpoResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-list-place-opo).
    ///
    pub async fn order_list_place_opo(
        &self,
        params: OrderListPlaceOpoParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderListPlaceOpoResponseResult>>> {
        self.trade_api_client.order_list_place_opo(params).await
    }

    /// OPOCO (TRADE)
    ///
    /// Place an [OPOCO](/products/spot/faqs/opo).
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 3
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderListPlaceOpocoParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderListPlaceOpocoResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-list-place-opoco).
    ///
    pub async fn order_list_place_opoco(
        &self,
        params: OrderListPlaceOpocoParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderListPlaceOpocoResponseResult>>> {
        self.trade_api_client.order_list_place_opoco(params).await
    }

    /// Place new Order list - OTO (TRADE)
    ///
    /// Places an OTO.
    ///
    /// * An OTO (One-Triggers-the-Other) is an order list comprised of 2 orders.
    ///
    /// * The first order is called the **working order** and must be `LIMIT` or `LIMIT_MAKER`. Initially, only the
    /// working order goes on the order book.
    ///
    /// * The second order is called the **pending order**. It can be any order type except for `MARKET` orders using
    /// parameter `quoteOrderQty`. The pending order is only placed on the order book when the working order gets
    /// **fully filled**.
    ///
    /// * If either the working order or the pending order is cancelled individually, the other order in the order list
    /// will also be canceled or expired.
    ///
    /// * When the order list is placed, if the working order gets **immediately fully filled**, the placement response
    /// will show the working order as `FILLED` but the pending order will still appear as `PENDING_NEW`. You need to
    /// query the status of the pending order again to see its updated status.
    ///
    /// * OTOs add **2 orders** to the `EXCHANGE_MAX_NUM_ORDERS` filter and `MAX_NUM_ORDERS` filter.
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 2
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// **Mandatory parameters based on `pendingType` or `workingType`**
    ///
    /// Depending on the `pendingType` or `workingType`, some optional parameters will become mandatory.
    ///
    /// |Type                                                  |Additional mandatory parameters|Additional information|
    /// |----                                                  |----                           |------
    /// |`workingType` = `LIMIT`                               |`workingTimeInForce`           |
    /// |`pendingType` = `LIMIT`                                |`pendingPrice`, `pendingTimeInForce`          |
    /// |`pendingType` = `STOP_LOSS` or `TAKE_PROFIT`           |`pendingStopPrice` and/or `pendingTrailingDelta`|
    /// |`pendingType` =`STOP_LOSS_LIMIT` or `TAKE_PROFIT_LIMIT`|`pendingPrice`, `pendingStopPrice` and/or `pendingTrailingDelta`, `pendingTimeInForce`|
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderListPlaceOtoParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderListPlaceOtoResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-list-place-oto).
    ///
    pub async fn order_list_place_oto(
        &self,
        params: OrderListPlaceOtoParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderListPlaceOtoResponseResult>>> {
        self.trade_api_client.order_list_place_oto(params).await
    }

    /// Place new Order list - OTOCO (TRADE)
    ///
    /// Place an OTOCO.
    ///
    /// * An OTOCO (One-Triggers-One-Cancels-the-Other) is an order list comprised of 3 orders.
    /// * The first order is called the **working order** and must be `LIMIT` or `LIMIT_MAKER`. Initially, only the working order goes on the order book.
    /// * The behavior of the working order is the same as the [OTO](#order-list-place-oto).
    /// * OTOCO has 2 pending orders (pending above and pending below), forming an OCO pair. The pending orders are only placed on the order book when the working order gets **fully filled**.
    /// * The rules of the pending above and pending below follow the same rules as the [Order list OCO](#order-list-place-oco).
    /// * OTOCOs add **3 orders** to the `EXCHANGE_MAX_NUM_ORDERS` filter and `MAX_NUM_ORDERS` filter.
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 3
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// **Mandatory parameters based on `pendingAboveType`, `pendingBelowType` or `workingType`**
    ///
    /// Depending on the `pendingAboveType`/`pendingBelowType` or `workingType`, some optional parameters will become mandatory.
    ///
    /// |Type                                                       |Additional mandatory parameters|Additional information|
    /// |----                                                       |----                           |------
    /// |`workingType` = `LIMIT`                                    |`workingTimeInForce`           |
    /// |`pendingAboveType`= `LIMIT_MAKER`                                |`pendingAbovePrice`          |
    /// |`pendingAboveType` = `STOP_LOSS/TAKE_PROFIT`         |`pendingAboveStopPrice` and/or `pendingAboveTrailingDelta`|
    /// |`pendingAboveType=STOP_LOSS_LIMIT/TAKE_PROFIT_LIMIT`|`pendingAbovePrice`, `pendingAboveStopPrice` and/or `pendingAboveTrailingDelta`, `pendingAboveTimeInForce`|
    /// |`pendingBelowType`= `LIMIT_MAKER`                                |`pendingBelowPrice`          |
    /// `pendingBelowType= STOP_LOSS/TAKE_PROFIT`         |`pendingBelowStopPrice` and/or `pendingBelowTrailingDelta`|
    /// |`pendingBelowType=STOP_LOSS_LIMIT/TAKE_PROFIT_LIMIT`|`pendingBelowPrice`, `pendingBelowStopPrice` and/or `pendingBelowTrailingDelta`, `pendingBelowTimeInForce`|
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderListPlaceOtocoParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderListPlaceOtocoResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-list-place-otoco).
    ///
    pub async fn order_list_place_otoco(
        &self,
        params: OrderListPlaceOtocoParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderListPlaceOtocoResponseResult>>> {
        self.trade_api_client.order_list_place_otoco(params).await
    }

    /// Place new order (TRADE)
    ///
    /// Send in a new order.
    ///
    /// This adds 1 order to the `EXCHANGE_MAX_ORDERS` filter and the `MAX_NUM_ORDERS` filter.
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 1
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// <a id="order-type">Certain parameters (*)</a> become mandatory based on the order `type`:
    ///
    /// <table>
    /// <thead>
    /// <tr>
    /// <th>Order <code>type</code></th>
    /// <th>Mandatory parameters</th>
    /// </tr>
    /// </thead>
    /// <tbody>
    /// <tr>
    /// <td><code>LIMIT</code></td>
    /// <td>
    /// <ul>
    /// <li><code>timeInForce</code></li>
    /// <li><code>price</code></li>
    /// <li><code>quantity</code></li>
    /// </ul>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>LIMIT_MAKER</code></td>
    /// <td>
    /// <ul>
    /// <li><code>price</code></li>
    /// <li><code>quantity</code></li>
    /// </ul>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>MARKET</code></td>
    /// <td>
    /// <ul>
    /// <li><code>quantity</code> or <code>quoteOrderQty</code></li>
    /// </ul>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>STOP_LOSS</code></td>
    /// <td>
    /// <ul>
    /// <li><code>quantity</code></li>
    /// <li><code>stopPrice</code> or <code>trailingDelta</code></li>
    /// </ul>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>STOP_LOSS_LIMIT</code></td>
    /// <td>
    /// <ul>
    /// <li><code>timeInForce</code></li>
    /// <li><code>price</code></li>
    /// <li><code>quantity</code></li>
    /// <li><code>stopPrice</code> or <code>trailingDelta</code></li>
    /// </ul>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>TAKE_PROFIT</code></td>
    /// <td>
    /// <ul>
    /// <li><code>quantity</code></li>
    /// <li><code>stopPrice</code> or <code>trailingDelta</code></li>
    /// </ul>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>TAKE_PROFIT_LIMIT</code></td>
    /// <td>
    /// <ul>
    /// <li><code>timeInForce</code></li>
    /// <li><code>price</code></li>
    /// <li><code>quantity</code></li>
    /// <li><code>stopPrice</code> or <code>trailingDelta</code></li>
    /// </ul>
    /// </td>
    /// </tr>
    /// </tbody>
    /// </table>
    ///
    /// Supported order types:
    ///
    /// <table>
    /// <thead>
    /// <tr>
    /// <th>Order <code>type</code></th>
    /// <th>Description</th>
    /// </tr>
    /// </thead>
    /// <tbody>
    /// <tr>
    /// <td><code>LIMIT</code></td>
    /// <td>
    /// <p>
    /// Buy or sell <code>quantity</code> at the specified <code>price</code> or better.
    /// </p>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>LIMIT_MAKER</code></td>
    /// <td>
    /// <p>
    /// <code>LIMIT</code> order that will be rejected if it immediately matches and trades as a taker.
    /// </p>
    /// <p>
    /// This order type is also known as a POST-ONLY order.
    /// </p>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>MARKET</code></td>
    /// <td>
    /// <p>
    /// Buy or sell at the best available market price.
    /// </p>
    /// <ul>
    /// <li>
    /// <p>
    /// <code>MARKET</code> order with <code>quantity</code> parameter
    /// specifies the amount of the <em>base asset</em> you want to buy or sell.
    /// Actually executed quantity of the quote asset will be determined by available market liquidity.
    /// </p>
    /// <p>
    /// E.g., a MARKET BUY order on BTCUSDT for <code>"quantity": "0.1000"</code>
    /// specifies that you want to buy 0.1 BTC at the best available price.
    /// If there is not enough BTC at the best price, keep buying at the next best price,
    /// until either your order is filled, or you run out of USDT, or market runs out of BTC.
    /// </p>
    /// </li>
    /// <li>
    /// <p>
    /// <code>MARKET</code> order with <code>quoteOrderQty</code> parameter
    /// specifies the amount of the <em>quote asset</em> you want to spend (when buying) or receive (when selling).
    /// Actually executed quantity of the base asset will be determined by available market liquidity.
    /// </p>
    /// <p>
    /// E.g., a MARKET BUY on BTCUSDT for <code>"quoteOrderQty": "100.00"</code>
    /// specifies that you want to buy as much BTC as you can for 100 USDT at the best available price.
    /// Similarly, a SELL order will sell as much available BTC as needed for you to receive 100 USDT
    /// (before commission).
    /// </p>
    /// </li>
    /// </ul>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>STOP_LOSS</code></td>
    /// <td>
    /// <p>
    /// Execute a <code>MARKET</code> order for given <code>quantity</code> when specified conditions are met.
    /// </p>
    /// <p>
    /// I.e., when <code>stopPrice</code> is reached, or when <code>trailingDelta</code> is activated.
    /// </p>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>STOP_LOSS_LIMIT</code></td>
    /// <td>
    /// <p>
    /// Place a <code>LIMIT</code> order with given parameters when specified conditions are met.
    /// </p>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>TAKE_PROFIT</code></td>
    /// <td>
    /// <p>
    /// Like <code>STOP_LOSS</code> but activates when market price moves in the favorable direction.
    /// </p>
    /// </td>
    /// </tr>
    /// <tr>
    /// <td><code>TAKE_PROFIT_LIMIT</code></td>
    /// <td>
    /// <p>
    /// Like <code>STOP_LOSS_LIMIT</code> but activates when market price moves in the favorable direction.
    /// </p>
    /// </td>
    /// </tr>
    /// </tbody>
    /// </table>
    ///
    /// <a id="pegged-orders-info"></a>
    /// Notes on using parameters for Pegged Orders:
    ///
    /// * These parameters are allowed for `LIMIT`, `LIMIT_MAKER`, `STOP_LOSS_LIMIT`, `TAKE_PROFIT_LIMIT` orders.
    /// * If `pegPriceType` is specified, `price` becomes optional. Otherwise, it is still mandatory.
    /// * `pegPriceType=PRIMARY_PEG` means the primary peg, that is the best price on the same side of the order book as your order.
    /// * `pegPriceType=MARKET_PEG` means the market peg, that is the best price on the opposite side of the order book from your order.
    /// * Use `pegOffsetType` and `pegOffsetValue` to request a price level other than the best one. These parameters must be specified together.
    ///
    /// <a id="timeInForce"></a>
    ///
    /// Available `timeInForce` options,
    /// setting how long the order should be active before expiration:
    ///
    /// TIF  | Description
    /// ----- | --------------
    /// `GTC` | **Good 'til Canceled** – the order will remain on the book until you cancel it, or the order is completely filled.
    /// `IOC` | **Immediate or Cancel** – the order will be filled for as much as possible, the unfilled quantity immediately expires.
    /// `FOK` | **Fill or Kill** – the order will expire unless it cannot be immediately filled for the entire quantity.
    ///
    /// Notes:
    ///
    /// * `newClientOrderId` specifies `clientOrderId` value for the order.
    ///
    /// A new order with the same `clientOrderId` is accepted only when the previous one is filled or expired.
    ///
    /// * Any `LIMIT` or `LIMIT_MAKER` order can be made into an iceberg order by specifying the `icebergQty`.
    ///
    /// An order with an `icebergQty` must have `timeInForce` set to `GTC`.
    ///
    /// * Trigger order price rules for `STOP_LOSS`/`TAKE_PROFIT` orders:
    ///
    /// * `stopPrice` must be above market price: `STOP_LOSS BUY`, `TAKE_PROFIT SELL`
    /// * `stopPrice` must be below market price: `STOP_LOSS SELL`, `TAKE_PROFIT BUY`
    ///
    /// * `MARKET` orders using `quoteOrderQty` follow [`LOT_SIZE`](/products/spot/filters#lot_size) filter rules.
    ///
    /// The order will execute a quantity that has notional value as close as possible to requested `quoteOrderQty`.
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderPlaceParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderPlaceResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-place).
    ///
    pub async fn order_place(
        &self,
        params: OrderPlaceParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderPlaceResponseResult>>> {
        self.trade_api_client.order_place(params).await
    }

    /// Test new order (TRADE)
    ///
    /// Test order placement.
    ///
    /// Validates new order parameters and verifies your signature
    /// but does not send the order into the matching engine.
    ///
    /// Weight: | Condition | Request Weight |
    /// | --- | --- |
    /// | Without `computeCommissionRates` | 1 |
    /// | With `computeCommissionRates` | 20 |
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`OrderTestParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::OrderTestResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#order-test).
    ///
    pub async fn order_test(
        &self,
        params: OrderTestParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::OrderTestResponseResult>>> {
        self.trade_api_client.order_test(params).await
    }

    /// Place new order using SOR (TRADE)
    ///
    /// Places an order using smart order routing (SOR).
    ///
    /// This adds 1 order to the `EXCHANGE_MAX_ORDERS` filter and the `MAX_NUM_ORDERS` filter.
    ///
    /// Read [SOR FAQ](/products/spot/faqs/sor_faq) to learn more.
    ///
    /// Weight(IP): 1
    ///
    /// Unfilled Order Count: 1
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Matching Engine
    ///
    /// **Note:** `sor.order.place` only supports `LIMIT` and `MARKET` orders. `quoteOrderQty` is not supported.
    ///
    /// # Arguments
    ///
    /// - `params`: [`SorOrderPlaceParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::SorOrderPlaceResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#sor-order-place).
    ///
    pub async fn sor_order_place(
        &self,
        params: SorOrderPlaceParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::SorOrderPlaceResponseResultInner>>> {
        self.trade_api_client.sor_order_place(params).await
    }

    /// Test new order using SOR (TRADE)
    ///
    /// Test new order creation and signature/recvWindow using smart order routing (SOR).
    /// Creates and validates a new order but does not send it into the matching engine.
    ///
    /// Weight: | Condition | Request Weight |
    /// | --- | --- |
    /// | Without `computeCommissionRates` | 1 |
    /// | With `computeCommissionRates` | 20 |
    ///
    /// Security Type: TRADE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`SorOrderTestParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::SorOrderTestResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/trade#sor-order-test).
    ///
    pub async fn sor_order_test(
        &self,
        params: SorOrderTestParams,
    ) -> anyhow::Result<WebsocketApiResponse<Box<models::SorOrderTestResponseResult>>> {
        self.trade_api_client.sor_order_test(params).await
    }

    /// Listing all subscriptions
    ///
    /// **Note:**
    ///
    /// * Users should track the corresponding subscription status of related accounts as needed.
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`SessionSubscriptionsParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Vec<models::SessionSubscriptionsResponseResultInner>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/user-data-stream#session-subscriptions).
    ///
    pub async fn session_subscriptions(
        &self,
        params: SessionSubscriptionsParams,
    ) -> anyhow::Result<WebsocketApiResponse<Vec<models::SessionSubscriptionsResponseResultInner>>>
    {
        self.user_data_stream_api_client
            .session_subscriptions(params)
            .await
    }

    /// Subscribe to User Data Stream
    ///
    /// Subscribe to the User Data Stream in the current WebSocket connection.
    ///
    /// **Notes:**
    /// - This method requires an authenticated WebSocket connection using Ed25519 keys. Please refer to [`session.logon`](/catalog/core-trading-spot-trading/api/ws-api/auth#session-logon).
    /// - To check the subscription status, use [`session.status`](/catalog/core-trading-spot-trading/api/ws-api/auth#session-status), see the `userDataStream` flag indicating you have have an active subscription.
    /// - User Data Stream events are available in both JSON and [SBE](/products/spot/faqs/sbe_faq) sessions.
    /// - Please refer to [User Data Streams](/products/spot/user-data-stream) for the event format details.
    /// - For SBE, only SBE schema 2:1 or later is supported.
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: NONE
    ///
    /// # Arguments
    ///
    /// - `params`: [`UserDataStreamSubscribeParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::UserDataStreamSubscribeResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/user-data-stream#user-data-stream-subscribe).
    ///
    pub async fn user_data_stream_subscribe(
        &self,
        params: UserDataStreamSubscribeParams,
    ) -> anyhow::Result<(
        WebsocketApiResponse<Box<models::UserDataStreamSubscribeResponseResult>>,
        Arc<WebsocketStream<UserDataStreamEventsResponse>>,
    )> {
        let response = self
            .user_data_stream_api_client
            .user_data_stream_subscribe(params)
            .await?;
        let stream = create_stream_handler::<UserDataStreamEventsResponse>(
            WebsocketBase::WebsocketApi(self.websocket_api_base.clone()),
            random_string(),
            None,
            None,
        )
        .await;

        Ok((response, stream))
    }

    /// Subscribe to User Data Stream through signature subscription (`USER_STREAM`)
    ///
    /// Weight(IP): 2
    ///
    /// Security Type: `USER_STREAM`
    ///
    /// Notes:
    /// **Data Source:** Memory
    ///
    /// # Arguments
    ///
    /// - `params`: [`UserDataStreamSubscribeSignatureParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<Box<models::UserDataStreamSubscribeResponseResult>>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/user-data-stream#user-data-stream-subscribe-signature).
    ///
    pub async fn user_data_stream_subscribe_signature(
        &self,
        params: UserDataStreamSubscribeSignatureParams,
    ) -> anyhow::Result<(
        WebsocketApiResponse<Box<models::UserDataStreamSubscribeResponseResult>>,
        Arc<WebsocketStream<UserDataStreamEventsResponse>>,
    )> {
        let response = self
            .user_data_stream_api_client
            .user_data_stream_subscribe_signature(params)
            .await?;
        let stream = create_stream_handler::<UserDataStreamEventsResponse>(
            WebsocketBase::WebsocketApi(self.websocket_api_base.clone()),
            random_string(),
            None,
            None,
        )
        .await;

        Ok((response, stream))
    }

    /// WebSocket Unsubscribe from User Data Stream
    ///
    /// Stop listening to the User Data Stream in the current WebSocket
    /// connection.
    ///
    /// Note that `session.logout` will only close the subscription created with `userDataStream.subscribe` but not subscriptions opened with `userDataStream.subscribe.signature`.
    ///
    /// Weight(IP): 2
    ///
    /// # Arguments
    ///
    /// - `params`: [`UserDataStreamUnsubscribeParams`]
    ///   The parameters for this operation.
    ///
    /// # Returns
    ///
    /// [`WebsocketApiResponse<serde_json::Value>`] on success.
    ///
    /// # Errors
    ///
    /// Returns an [`anyhow::Error`] if the WebSocket request fails, if parameters are invalid, or if parsing the response fails.
    ///
    ///
    /// For full API details, see the [Binance API Documentation](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-api/user-data-stream#user-data-stream-unsubscribe).
    ///
    pub async fn user_data_stream_unsubscribe(
        &self,
        params: UserDataStreamUnsubscribeParams,
    ) -> anyhow::Result<WebsocketApiResponse<serde_json::Value>> {
        self.user_data_stream_api_client
            .user_data_stream_unsubscribe(params)
            .await
    }
}