Struct OrderBuilder 

pub struct OrderBuilder<'a, C> { /* private fields */ }

Builder for creating orders with a fluent interface

All validation is deferred to the build() method to ensure no silent failures occur during order construction.

Implementations

impl<'a, C> OrderBuilder<'a, C>

pub fn new(client: &'a C, contract: &'a Contract) -> Self

Creates a new OrderBuilder

pub fn buy(self, quantity: impl Into<f64>) -> Self

Set order to buy the specified quantity

pub fn sell(self, quantity: impl Into<f64>) -> Self

Set order to sell the specified quantity

pub fn market(self) -> Self

Create a market order

pub fn limit(self, price: impl Into<f64>) -> Self

Create a limit order at the specified price

pub fn stop(self, stop_price: impl Into<f64>) -> Self

Create a stop order at the specified stop price

pub fn stop_limit( self, stop_price: impl Into<f64>, limit_price: impl Into<f64>, ) -> Self

Create a stop-limit order

pub fn trailing_stop( self, trailing_percent: f64, stop_price: impl Into<f64>, ) -> Self

Create a trailing stop order

pub fn order_type(self, order_type: OrderType) -> Self

Set a custom order type

pub fn trailing_stop_limit( self, trailing_percent: f64, stop_price: impl Into<f64>, limit_offset: f64, ) -> Self

Create a trailing stop limit order

pub fn market_if_touched(self, trigger_price: impl Into<f64>) -> Self

Market if Touched - triggers market order when price is touched

pub fn limit_if_touched( self, trigger_price: impl Into<f64>, limit_price: impl Into<f64>, ) -> Self

Limit if Touched - triggers limit order when price is touched

pub fn market_to_limit(self) -> Self

Market to Limit - starts as market order, remainder becomes limit

pub fn discretionary( self, limit_price: impl Into<f64>, discretionary_amt: f64, ) -> Self

Discretionary order - limit order with hidden discretionary amount

pub fn sweep_to_fill(self, limit_price: impl Into<f64>) -> Self

Sweep to Fill - prioritizes speed of execution over price

pub fn block(self, limit_price: impl Into<f64>) -> Self

Block order - for large volume option orders (min 50 contracts)

pub fn midprice(self, price_cap: impl Into<f64>) -> Self

Midprice order - fills at midpoint between bid/ask or better

pub fn relative(self, offset: f64, price_cap: Option<f64>) -> Self

Relative/Pegged-to-Primary - seeks more aggressive price than NBBO

pub fn passive_relative(self, offset: f64) -> Self

Passive Relative - seeks less aggressive price than NBBO

pub fn at_auction(self, price: impl Into<f64>) -> Self

At Auction - for pre-market opening period execution

pub fn time_in_force(self, tif: TimeInForce) -> Self

Set time in force for the order

pub fn day_order(self) -> Self

Order valid for the day only

pub fn good_till_cancel(self) -> Self

Good till cancelled order

pub fn good_till_date(self, date: impl Into<String>) -> Self

Good till specific date

pub fn fill_or_kill(self) -> Self

Fill or kill order

pub fn immediate_or_cancel(self) -> Self

Immediate or cancel order

pub fn outside_rth(self) -> Self

Allow order execution outside regular trading hours

pub fn regular_hours_only(self) -> Self

Restrict order to regular trading hours only

pub fn trading_hours(self, hours: TradingHours) -> Self

Set trading hours preference

pub fn hidden(self) -> Self

Hide order from market depth (only works for NASDAQ-routed orders)

pub fn account(self, account: impl Into<String>) -> Self

Set account for order

pub fn parent(self, parent_id: i32) -> Self

Set parent order ID for attached orders

pub fn oca_group(self, group: impl Into<String>, oca_type: i32) -> Self

Set OCA group

pub fn do_not_transmit(self) -> Self

Do not transmit order immediately

pub fn bracket(self) -> BracketOrderBuilder<'a, C>

Create bracket orders with take profit and stop loss

pub fn algo(self, strategy: impl Into<String>) -> Self

Set algorithm strategy

pub fn algo_param( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add algorithm parameter

pub fn what_if(self) -> Self

Mark as what-if order for margin/commission calculation

pub fn volatility(self, volatility: f64) -> Self

Set volatility for volatility orders

pub fn not_held(self) -> Self

Mark order as not held

pub fn all_or_none(self) -> Self

Mark order as all or none

pub fn good_after_time(self, time: impl Into<String>) -> Self

Set good after time

pub fn good_till_time(self, time: impl Into<String>) -> Self

Set good till time (stored in good_till_date field)

pub fn min_trade_qty(self, qty: i32) -> Self

Set minimum trade quantity for pegged orders

pub fn min_compete_size(self, size: i32) -> Self

Set minimum compete size for pegged orders

pub fn compete_against_best_offset(self, offset: f64) -> Self

Set compete against best offset for pegged orders

pub fn mid_offset_at_whole(self, offset: f64) -> Self

Set mid offset at whole for pegged orders

pub fn mid_offset_at_half(self, offset: f64) -> Self

Set mid offset at half for pegged orders

pub fn build(self) -> Result<Order, ValidationError>

Build the Order struct with full validation

impl<'a> OrderBuilder<'a, Client>

pub fn submit(self) -> Result<OrderId, Error>

Submit the order synchronously Returns the order ID assigned to the submitted order

pub fn build_order(self) -> Result<Order, Error>

Build the order and return it without submitting Useful for batch operations or custom submission logic

pub fn analyze(self) -> Result<OrderState, Error>

Analyze order for margin/commission (what-if)

impl<'a> OrderBuilder<'a, Client>

pub async fn submit(self) -> Result<OrderId, Error>

Submit the order asynchronously Returns the order ID assigned to the submitted order

pub fn build_order(self) -> Result<Order, Error>

Build the order and return it without submitting Useful for batch operations or custom submission logic

pub async fn analyze(self) -> Result<OrderState, Error>

Analyze order for margin/commission (what-if)