wboayue / rust-ibapi / 18546784772

//! Client implementation for connecting to and communicating with TWS and IB Gateway.

//!

//! The Client provides the main interface for establishing connections, sending requests,

//! and receiving responses from the Interactive Brokers API. It manages message routing,

//! subscriptions, and maintains the connection state.

use std::fmt::Debug;

use std::net::TcpStream;

use std::sync::Arc;

use std::time::Duration;

use log::debug;

use time::{Date, OffsetDateTime};

use time_tz::Tz;

use crate::accounts::types::{AccountGroup, AccountId, ContractId, ModelCode};

use crate::accounts::{AccountSummaryResult, AccountUpdate, AccountUpdateMulti, FamilyCode, PnL, PnLSingle, PositionUpdate, PositionUpdateMulti};

use crate::connection::{sync::Connection, ConnectionMetadata};

use crate::contracts::{Contract, OptionComputation, SecurityType};

use crate::errors::Error;

use crate::market_data::builder::MarketDataBuilder;

use crate::market_data::historical::{self, HistogramEntry};

use crate::market_data::realtime::{self, Bar, BarSize, DepthMarketDataDescription, MarketDepths, MidPoint, WhatToShow};

use crate::market_data::{MarketDataType, TradingHours};

use crate::messages::{OutgoingMessages, RequestMessage};

use crate::news::NewsArticle;

use crate::orders::{CancelOrder, Executions, ExerciseOptions, Order, OrderBuilder, OrderUpdate, Orders, PlaceOrder};

use crate::scanner::ScannerData;

use crate::subscriptions::sync::Subscription;

use crate::transport::{InternalSubscription, MessageBus, TcpMessageBus, TcpSocket};

use crate::wsh::AutoFill;

use crate::{accounts, contracts, market_data, news, orders, scanner, wsh};

use super::id_generator::ClientIdManager;

// Client

/// TWS API Client. Manages the connection to TWS or Gateway.

/// Tracks some global information such as server version and server time.

/// Supports generation of order ids.

pub struct Client {

    /// IB server version

    pub(crate) server_version: i32,

    pub(crate) connection_time: Option<OffsetDateTime>,

    pub(crate) time_zone: Option<&'static Tz>,

    pub(crate) message_bus: Arc<dyn MessageBus>,

    client_id: i32,              // ID of client.

    id_manager: ClientIdManager, // Manages request and order ID generation

}

impl Client {

    /// Establishes connection to TWS or Gateway

    ///

    /// Connects to server using the given connection string

    ///

    /// # Arguments

    /// * `address`   - address of server. e.g. 127.0.0.1:4002

    /// * `client_id` - id of client. e.g. 100

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// println!("server_version: {}", client.server_version());

    /// println!("connection_time: {:?}", client.connection_time());

    /// println!("next_order_id: {}", client.next_order_id());

    /// ```

        let connection_metadata = connection.connection_metadata();

        // Starts thread to read messages from TWS

    }

        let client = Client {

            message_bus,

        };

    }

    /// Returns the ID assigned to the [Client].

    }

    /// Returns the next request ID.

    }

    /// Returns and increments the order ID.

    ///

    /// The client maintains a sequence of order IDs. This function returns the next order ID in the sequence.

    }

    /// Gets the next valid order ID from the TWS server.

    ///

    /// Unlike [Self::next_order_id], this function requests the next valid order ID from the TWS server and updates the client's internal order ID sequence.

    /// This can be for ensuring that order IDs are unique across multiple clients.

    ///

    /// Use this method when coordinating order IDs across multiple client instances or when you need to synchronize with the server's order ID sequence at the start of a session.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// // Connect to the TWS server at the given address with client ID.

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// // Request the next valid order ID from the server.

    /// let next_valid_order_id = client.next_valid_order_id().expect("request failed");

    /// println!("next_valid_order_id: {next_valid_order_id}");

    /// ```

    }

    /// Sets the current value of order ID.

    }

    /// Start building an order for the given contract

    ///

    /// This is the primary API for creating orders, providing a fluent interface

    /// that guides you through the order creation process.

    ///

    /// # Example

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::contracts::Contract;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    /// let contract = Contract::stock("AAPL").build();

    ///

    /// let order_id = client.order(&contract)

    ///     .buy(100)

    ///     .limit(50.0)

    ///     .submit().expect("order submission failed");

    /// ```

    }

    /// Returns the version of the TWS API server to which the client is connected.

    /// This version is determined during the initial connection handshake.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    /// let server_version = client.server_version();

    /// println!("Connected to TWS server version: {server_version:?}");

    /// ```

    }

    /// The time of the server when the client connected

    }

    /// Returns true if the client is currently connected to TWS/IB Gateway.

    ///

    /// This method checks if the underlying connection to TWS or IB Gateway is active.

    /// Returns false if the connection has been lost, shut down, or reset.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// if client.is_connected() {

    ///     println!("Client is connected to TWS/Gateway");

    /// } else {

    ///     println!("Client is not connected");

    /// }

    /// ```

    }

    // === Accounts ===

    /// TWS's current time. TWS is synchronized with the server (not local computer) using NTP and this function will receive the current time in TWS.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    /// let server_time = client.server_time().expect("error requesting server time");

    /// println!("server time: {server_time:?}");

    /// ```

    }

    /// Subscribes to [PositionUpdate]s for all accessible accounts.

    /// All positions sent initially, and then only updates as positions change.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::accounts::PositionUpdate;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    /// let subscription = client.positions().expect("error requesting positions");

    /// for position_response in subscription.iter() {

    ///     match position_response {

    ///         PositionUpdate::Position(position) => println!("{position:?}"),

    ///         PositionUpdate::PositionEnd => println!("initial set of positions received"),

    ///     }

    /// }

    /// ```

    }

    /// Subscribes to [PositionUpdateMulti] updates for account and/or model.

    /// Initially all positions are returned, and then updates are returned for any position changes in real time.

    ///

    /// # Arguments

    /// * `account`    - If an account Id is provided, only the account’s positions belonging to the specified model will be delivered.

    /// * `model_code` - The code of the model’s positions we are interested in.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// use ibapi::accounts::types::AccountId;

    ///

    /// let account = AccountId("U1234567".to_string());

    /// let subscription = client.positions_multi(Some(&account), None).expect("error requesting positions by model");

    /// for position in subscription.iter() {

    ///     println!("{position:?}")

    /// }

    /// ```

    }

    /// Creates subscription for real time daily PnL and unrealized PnL updates.

    ///

    /// # Arguments

    /// * `account`    - account for which to receive PnL updates

    /// * `model_code` - specify to request PnL updates for a specific model

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    /// use ibapi::accounts::types::AccountId;

    ///

    /// let account = AccountId("account id".to_string());

    /// let subscription = client.pnl(&account, None).expect("error requesting pnl");

    /// for pnl in subscription.iter() {

    ///     println!("{pnl:?}")

    /// }

    /// ```

    }

    /// Requests real time updates for daily PnL of individual positions.

    ///

    /// # Arguments

    /// * `account`     - Account in which position exists

    /// * `contract_id` - Contract ID of contract to receive daily PnL updates for. Note: does not return response if invalid conId is entered.

    /// * `model_code`  - Model in which position exists

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// use ibapi::accounts::types::{AccountId, ContractId};

    ///

    /// let account = AccountId("<account id>".to_string());

    /// let contract_id = ContractId(1001);

    ///

    /// let subscription = client.pnl_single(&account, contract_id, None).expect("error requesting pnl");

    /// for pnl in &subscription {

    ///     println!("{pnl:?}")

    /// }

    /// ```

    }

    /// Requests a specific account’s summary. Subscribes to the account summary as presented in the TWS’ Account Summary tab. Data received is specified by using a specific tags value.

    ///

    /// # Arguments

    /// * `group` - Set to “All” to return account summary data for all accounts, or set to a specific Advisor Account Group name that has already been created in TWS Global Configuration.

    /// * `tags`  - List of the desired tags.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::accounts::AccountSummaryTags;

    /// use ibapi::accounts::types::AccountGroup;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let group = AccountGroup("All".to_string());

    ///

    /// let subscription = client.account_summary(&group, &[AccountSummaryTags::ACCOUNT_TYPE]).expect("error requesting account summary");

    /// for summary in &subscription {

    ///     println!("{summary:?}")

    /// }

    /// ```

    }

    /// Subscribes to a specific account’s information and portfolio.

    ///

    /// All account values and positions will be returned initially, and then there will only be updates when there is a change in a position, or to an account value every 3 minutes if it has changed. Only one account can be subscribed at a time.

    ///

    /// # Arguments

    /// * `account` - The account id (i.e. U1234567) for which the information is requested.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::accounts::AccountUpdate;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// use ibapi::accounts::types::AccountId;

    ///

    /// let account = AccountId("U1234567".to_string());

    ///

    /// let subscription = client.account_updates(&account).expect("error requesting account updates");

    /// for update in &subscription {

    ///     println!("{update:?}");

    ///

    ///     // stop after full initial update

    ///     if let AccountUpdate::End = update {

    ///         subscription.cancel();

    ///     }

    /// }

    /// ```

    }

    /// Requests account updates for account and/or model.

    ///

    /// All account values and positions will be returned initially, and then there will only be updates when there is a change in a position, or to an account value every 3 minutes if it has changed. Only one account can be subscribed at a time.

    ///

    /// # Arguments

    /// * `account`        - Account values can be requested for a particular account.

    /// * `model_code`     - Account values can also be requested for a model.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::accounts::AccountUpdateMulti;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// use ibapi::accounts::types::AccountId;

    ///

    /// let account = AccountId("U1234567".to_string());

    ///

    /// let subscription = client.account_updates_multi(Some(&account), None).expect("error requesting account updates multi");

    /// for update in &subscription {

    ///     println!("{update:?}");

    ///

    ///     // stop after full initial update

    ///     if let AccountUpdateMulti::End = update {

    ///         subscription.cancel();

    ///     }

    /// }

    /// ```

        &self,

        account: Option<&AccountId>,

        model_code: Option<&ModelCode>,

    ) -> Result<Subscription<AccountUpdateMulti>, Error> {

    }

    /// Requests the accounts to which the logged user has access to.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let accounts = client.managed_accounts().expect("error requesting managed accounts");

    /// println!("managed accounts: {accounts:?}")

    /// ```

    }

    // === Contracts ===

    /// Requests contract information.

    ///

    /// Provides all the contracts matching the contract provided. It can also be used to retrieve complete options and futures chains. Though it is now (in API version > 9.72.12) advised to use [Client::option_chain] for that purpose.

    ///

    /// # Arguments

    /// * `contract` - The [Contract] used as sample to query the available contracts. Typically, it will contain the [Contract]'s symbol, currency, security_type, and exchange.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::contracts::Contract;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let contract = Contract::stock("TSLA").build();

    /// let results = client.contract_details(&contract).expect("request failed");

    /// for contract_detail in results {

    ///     println!("contract: {contract_detail:?}");

    /// }

    /// ```

    }

    /// Get current [FamilyCode]s for all accessible accounts.

    }

    /// Requests details about a given market rule

    ///

    /// The market rule for an instrument on a particular exchange provides details about how the minimum price increment changes with price.

    /// A list of market rule ids can be obtained by invoking [Self::contract_details()] for a particular contract.

    /// The returned market rule ID list will provide the market rule ID for the instrument in the correspond valid exchange list in [contracts::ContractDetails].

    }

    /// Requests matching stock symbols.

    ///

    /// # Arguments

    /// * `pattern` - Either start of ticker symbol or (for larger strings) company name.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let contracts = client.matching_symbols("IB").expect("request failed");

    /// for contract in contracts {

    ///     println!("contract: {contract:?}");

    /// }

    /// ```

    }

    /// Calculates an option’s price based on the provided volatility and its underlying’s price.

    ///

    /// # Arguments

    /// * `contract`        - The [Contract] object representing the option for which the calculation is being requested.

    /// * `volatility`      - Hypothetical volatility as a percentage (e.g., 20.0 for 20%).

    /// * `underlying_price` - Hypothetical price of the underlying asset.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::contracts::Contract;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let contract = Contract::option("AAPL", "20251219", 150.0, "C");

    /// let calculation = client.calculate_option_price(&contract, 100.0, 235.0).expect("request failed");

    /// println!("calculation: {calculation:?}");

    /// ```

    }

    /// Calculates the implied volatility based on the hypothetical option price and underlying price.

    ///

    /// # Arguments

    /// * `contract`        - The [Contract] object representing the option for which the calculation is being requested.

    /// * `option_price`    - Hypothetical option price.

    /// * `underlying_price` - Hypothetical price of the underlying asset.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::contracts::Contract;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let contract = Contract::option("AAPL", "20230519", 150.0, "C");

    /// let calculation = client.calculate_implied_volatility(&contract, 25.0, 235.0).expect("request failed");

    /// println!("calculation: {calculation:?}");

    /// ```

    }

    /// Requests security definition option parameters for viewing a contract’s option chain.

    ///

    /// # Arguments

    /// `symbol`   - Contract symbol of the underlying.

    /// `exchange` - The exchange on which the returned options are trading. Can be set to the empty string for all exchanges.

    /// `security_type` - The type of the underlying security, i.e. STK

    /// `contract_id`   - The contract ID of the underlying security.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::contracts::SecurityType;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let symbol = "AAPL";

    /// let exchange = ""; // all exchanges

    /// let security_type = SecurityType::Stock;

    /// let contract_id = 265598;

    ///

    /// let subscription = client

    ///     .option_chain(symbol, exchange, security_type, contract_id)

    ///     .expect("request option chain failed!");

    ///

    /// for option_chain in &subscription {

    ///     println!("{option_chain:?}")

    /// }

    /// ```

        &self,

        symbol: &str,

        exchange: &str,

        security_type: SecurityType,

        contract_id: i32,

    ) -> Result<Subscription<contracts::OptionChain>, Error> {

    }

    // === Orders ===

    /// Requests all *current* open orders in associated accounts at the current moment.

    /// Open orders are returned once; this function does not initiate a subscription.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let subscription = client.all_open_orders().expect("request failed");

    /// for order_data in &subscription {

    ///    println!("{order_data:?}")

    /// }

    /// ```

    }

    /// Requests status updates about future orders placed from TWS. Can only be used with client ID 0.

    ///

    /// # Arguments

    /// * `auto_bind` - if set to true, the newly created orders will be assigned an API order ID and implicitly associated with this client. If set to false, future orders will not be.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 0).expect("connection failed");

    ///

    /// let subscription = client.auto_open_orders(false).expect("request failed");

    /// for order_data in &subscription {

    ///    println!("{order_data:?}")

    /// }

    /// ```

    }

    /// Cancels an active [Order] placed by the same API client ID.

    ///

    /// # Arguments

    /// * `order_id` - ID of the [Order] to cancel.

    /// * `manual_order_cancel_time` - Optional timestamp to specify the cancellation time. Use an empty string to use the current time.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let order_id = 15;

    /// let subscription = client.cancel_order(order_id, "").expect("request failed");

    /// for result in subscription {

    ///    println!("{result:?}");

    /// }

    /// ```

    }

    /// Requests completed [Order]s.

    ///

    /// # Arguments

    /// * `api_only` - request only orders placed by the API.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let subscription = client.completed_orders(false).expect("request failed");

    /// for order_data in &subscription {

    ///    println!("{order_data:?}")

    /// }

    /// ```

    }

    /// Requests current day's (since midnight) executions matching the filter.

    ///

    /// Only the current day's executions can be retrieved.

    /// Along with the [orders::ExecutionData], the [orders::CommissionReport] will also be returned.

    /// When requesting executions, a filter can be specified to receive only a subset of them

    ///

    /// # Arguments

    /// * `filter` - filter criteria used to determine which execution reports are returned

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::orders::ExecutionFilter;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let filter = ExecutionFilter{

    ///    side: "BUY".to_owned(),

    ///    ..ExecutionFilter::default()

    /// };

    ///

    /// let subscription = client.executions(filter).expect("request failed");

    /// for execution_data in &subscription {

    ///    println!("{execution_data:?}")

    /// }

    /// ```

    }

    /// Cancels all open [Order]s.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// client.global_cancel().expect("request failed");

    /// ```

    }

    /// Requests all open orders places by this specific API client (identified by the API client id).

    /// For client ID 0, this will bind previous manual TWS orders.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let subscription = client.open_orders().expect("request failed");

    /// for order_data in &subscription {

    ///    println!("{order_data:?}")

    /// }

    /// ```

    }

    /// Places or modifies an [Order].

    ///

    /// Submits an [Order] using [Client] for the given [Contract].

    /// Upon successful submission, the client will start receiving events related to the order's activity via the subscription, including order status updates and execution reports.

    ///

    /// # Arguments

    /// * `order_id` - ID for [Order]. Get next valid ID using [Client::next_order_id].

    /// * `contract` - [Contract] to submit order for.

    /// * `order` - [Order] to submit.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::contracts::Contract;

    /// use ibapi::orders::PlaceOrder;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let contract = Contract::stock("MSFT").build();

    /// let order = client.order(&contract)

    ///     .buy(100)

    ///     .market()

    ///     .build_order()

    ///     .expect("failed to build order");

    /// let order_id = client.next_order_id();

    ///

    /// let events = client.place_order(order_id, &contract, &order).expect("request failed");

    ///

    /// for event in &events {

    ///     match event {

    ///         PlaceOrder::OrderStatus(order_status) => {

    ///             println!("order status: {order_status:?}")

    ///         }

    ///         PlaceOrder::OpenOrder(open_order) => println!("open order: {open_order:?}"),

    ///         PlaceOrder::ExecutionData(execution) => println!("execution: {execution:?}"),

    ///         PlaceOrder::CommissionReport(report) => println!("commission report: {report:?}"),

    ///         PlaceOrder::Message(message) => println!("message: {message:?}"),

    ///    }

    /// }

    /// ```

    }

    /// Submits or modifies an [Order] without returning a subscription.

    ///

    /// This is a fire-and-forget method that submits an [Order] for the given [Contract]

    /// but does not return a subscription for order updates. To receive order status updates,

    /// fills, and commission reports, use the [`order_update_stream`](Client::order_update_stream) method

    /// or use [`place_order`](Client::place_order) instead which returns a subscription.

    ///

    /// # Arguments

    /// * `order_id` - ID for [Order]. Get next valid ID using [Client::next_order_id].

    /// * `contract` - [Contract] to submit order for.

    /// * `order` - [Order] to submit.

    ///

    /// # Returns

    /// * `Ok(())` if the order was successfully sent

    /// * `Err(Error)` if validation failed or sending failed

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::contracts::Contract;

    ///

    /// # fn main() -> Result<(), ibapi::Error> {

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100)?;

    ///

    /// let contract = Contract::stock("MSFT").build();

    /// let order = client.order(&contract)

    ///     .buy(100)

    ///     .market()

    ///     .build_order()?;

    /// let order_id = client.next_order_id();

    ///

    /// // Submit order without waiting for confirmation

    /// client.submit_order(order_id, &contract, &order)?;

    ///

    /// // Monitor all order updates via the order update stream

    /// // This will receive updates for ALL orders, not just this one

    /// use ibapi::orders::OrderUpdate;

    /// for event in client.order_update_stream()? {

    ///     match event {

    ///         OrderUpdate::OrderStatus(status) => println!("Order Status: {status:?}"),

    ///         OrderUpdate::ExecutionData(exec) => println!("Execution: {exec:?}"),

    ///         OrderUpdate::CommissionReport(report) => println!("Commission: {report:?}"),

    ///         _ => {}

    ///     }

    /// }

    ///

    /// # Ok(())

    /// # }

    /// ```

    }

    /// Creates a subscription stream for receiving real-time order updates.

    ///

    /// This method establishes a stream that receives all order-related events including:

    /// - Order status updates (e.g., submitted, filled, cancelled)

    /// - Open order information

    /// - Execution data for trades

    /// - Commission reports

    /// - Order-related messages and notices

    ///

    /// The stream will receive updates for all orders placed through this client connection,

    /// including both new orders submitted after creating the stream and existing orders.

    ///

    /// # Returns

    ///

    /// Returns a `Subscription<OrderUpdate>` that yields `OrderUpdate` enum variants containing:

    /// - `OrderStatus`: Current status of an order (filled amount, average price, etc.)

    /// - `OpenOrder`: Complete order details including contract and order parameters

    /// - `ExecutionData`: Details about individual trade executions

    /// - `CommissionReport`: Commission information for executed trades

    /// - `Message`: Notices or error messages related to orders

    ///

    /// # Errors

    ///

    /// Returns an error if the subscription cannot be created, typically due to

    /// connection issues or internal errors.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::orders::OrderUpdate;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// // Create order update stream

    /// let updates = client.order_update_stream().expect("failed to create stream");

    ///

    /// // Process order updates

    /// for update in updates {

    ///     match update {

    ///         OrderUpdate::OrderStatus(status) => {

    ///             println!("Order {} status: {} - filled: {}/{}",

    ///                 status.order_id, status.status, status.filled, status.remaining);

    ///         },

    ///         OrderUpdate::OpenOrder(order_data) => {

    ///             println!("Open order {}: {} {} @ {}",

    ///                 order_data.order.order_id,

    ///                 order_data.order.action,

    ///                 order_data.order.total_quantity,

    ///                 order_data.order.limit_price.unwrap_or(0.0));

    ///         },

    ///         OrderUpdate::ExecutionData(exec) => {

    ///             println!("Execution: {} {} @ {} on {}",

    ///                 exec.execution.side,

    ///                 exec.execution.shares,

    ///                 exec.execution.price,

    ///                 exec.execution.exchange);

    ///         },

    ///         OrderUpdate::CommissionReport(report) => {

    ///             println!("Commission: ${} for execution {}",

    ///                 report.commission, report.execution_id);

    ///         },

    ///         OrderUpdate::Message(notice) => {

    ///             println!("Order message: {}", notice.message);

    ///         }

    ///     }

    /// }

    /// ```

    ///

    /// # Note

    ///

    /// This stream provides updates for all orders, not just a specific order.

    /// To track a specific order, filter the updates by order ID.

    }

    /// Exercises an options contract.

    ///

    /// Note: this function is affected by a TWS setting which specifies if an exercise request must be finalized.

    ///

    /// # Arguments

    /// * `contract`          - The option [Contract] to be exercised.

    /// * `exercise_action`   - Exercise option. ExerciseAction::Exercise or ExerciseAction::Lapse.

    /// * `exercise_quantity` - Number of contracts to be exercised.

    /// * `account`           - Destination account.

    /// * `ovrd`              - Specifies whether your setting will override the system’s natural action. For example, if your action is "exercise" and the option is not in-the-money, by natural action the option would not exercise. If you have override set to true the natural action would be overridden and the out-of-the money option would be exercised.

    /// * `manual_order_time` - Specify the time at which the options should be exercised. If `None`, the current time will be used. Requires TWS API 10.26 or higher.

        &self,

        contract: &Contract,

        exercise_action: orders::ExerciseAction,

        exercise_quantity: i32,

        account: &str,

        ovrd: bool,

        manual_order_time: Option<OffsetDateTime>,

    ) -> Result<Subscription<ExerciseOptions>, Error> {

    }

    // === Historical Market Data ===

    /// Returns the timestamp of earliest available historical data for a contract and data type.

    ///

    /// ```no_run

    /// use ibapi::client::blocking::Client;

    /// use ibapi::contracts::Contract;

    /// use ibapi::market_data::historical::{self, WhatToShow};

    /// use ibapi::market_data::TradingHours;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let contract = Contract::stock("MSFT").build();

    /// let what_to_show = WhatToShow::Trades;

    /// let trading_hours = TradingHours::Regular;

    ///

    /// let result = client.head_timestamp(&contract, what_to_show, trading_hours).expect("head timestamp failed");

    ///

    /// print!("head_timestamp: {result:?}");

    /// ```

        &self,

        contract: &Contract,

        what_to_show: historical::WhatToShow,

        trading_hours: TradingHours,

    ) -> Result<OffsetDateTime, Error> {

    }

    /// Requests interval of historical data ending at specified time for [Contract].

    ///

    /// # Arguments

    /// * `contract`     - [Contract] to retrieve [historical::HistoricalData] for.

    /// * `interval_end` - optional end date of interval to retrieve [historical::HistoricalData] for. If `None` current time or last trading of contract is implied.

    /// * `duration`     - duration of interval to retrieve [historical::HistoricalData] for.

    /// * `bar_size`     - [historical::BarSize] to return.

    /// * `what_to_show` - requested bar type: [historical::WhatToShow].

    /// * `use_rth`      - use regular trading hours.

    ///

    /// # Examples

    ///

    /// ```no_run

    /// use time::macros::datetime;

    ///

    /// use ibapi::contracts::Contract;

    /// use ibapi::client::blocking::Client;

    /// use ibapi::market_data::historical::{BarSize, ToDuration, WhatToShow};

    /// use ibapi::market_data::TradingHours;

    ///

    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");

    ///

    /// let contract = Contract::stock("TSLA").build();

    ///

    /// let historical_data = client

    ///     .historical_data(&contract, Some(datetime!(2023-04-15 0:00 UTC)), 7.days(), BarSize::Day, WhatToShow::Trades, TradingHours::Regular)

    ///     .expect("historical data request failed");

    ///

    /// println!("start_date: {}, end_date: {}", historical_data.start, historical_data.end);

    ///

    /// for bar in &historical_data.bars {

    ///     println!("{bar:?}");

    /// }

    /// ```

        &self,

        contract: &Contract,

        interval_end: Option<OffsetDateTime>,

        duration: historical::Duration,

        bar_size: historical::BarSize,