Struct OrderRequest 

#[non_exhaustive]
pub struct OrderRequest { /* private fields */ }

Body of POST /accounts/{accountNumber}/orders (place) and PUT /accounts/{accountNumber}/orders/{orderId} (replace). Construct via OrderRequest::single (typestate builder) or via the composite-strategy factories OrderRequest::oco and OrderRequest::trigger.

Response-only fields (status, filledQuantity, enteredTime, tag, requestedDestination, etc.) are not present here; they live on Order instead.

Implementations

impl OrderRequest

pub fn session(&self) -> Option<&Session>

Session in which the order is eligible to trade.

pub fn duration(&self) -> Option<&Duration>

Time in force (DAY, GOOD_TILL_CANCEL, etc.).

pub fn order_type(&self) -> Option<&OrderType>

Order type (MARKET, LIMIT, STOP, NET_DEBIT, etc.).

pub fn complex_order_strategy_type(&self) -> Option<&ComplexOrderStrategyType>

Multi-leg option strategy shape, if any.

pub fn quantity(&self) -> Option<Decimal>

Top-level quantity, when Schwab carries it separately from the per-leg quantity.

pub fn price(&self) -> Option<Decimal>

Limit / net-debit / net-credit price.

pub fn stop_price(&self) -> Option<Decimal>

Stop-trigger price for stop and stop-limit orders.

pub fn special_instruction(&self) -> Option<&SpecialInstruction>

Special instruction (e.g. AllOrNone).

pub fn order_strategy_type(&self) -> Option<&OrderStrategyType>

Envelope strategy (SINGLE, OCO, TRIGGER, …).

pub fn legs(&self) -> &[OrderLegRequest]

Order legs.

pub fn child_strategies(&self) -> &[OrderRequest]

Child strategies of a composite envelope (OCO or TRIGGER). Empty for SINGLE.

impl OrderRequest

pub fn single() -> SingleOrderBuilder<NeedsType>

Begin building a SINGLE strategy order. Defaults session=NORMAL and duration=DAY; override with SingleOrderBuilder::session and SingleOrderBuilder::duration on the Ready state.

pub fn buy_market( symbol: impl Into<String>, qty: impl IntoQuantity, ) -> SingleOrderBuilder<Ready>

Equity buy-at-market, default day order.

pub fn buy_limit( symbol: impl Into<String>, qty: impl IntoQuantity, price: Decimal, ) -> SingleOrderBuilder<Ready>

Equity buy-at-limit, default day order.

pub fn sell_market( symbol: impl Into<String>, qty: impl IntoQuantity, ) -> SingleOrderBuilder<Ready>

Equity long-sale at market, default day order.

pub fn sell_limit( symbol: impl Into<String>, qty: impl IntoQuantity, price: Decimal, ) -> SingleOrderBuilder<Ready>

Equity long-sale at limit, default day order.

pub fn sell_stop( symbol: impl Into<String>, qty: impl IntoQuantity, stop_price: Decimal, ) -> SingleOrderBuilder<Ready>

Equity stop-market sell, default day order. Useful for stop-loss exits.

pub fn sell_stop_limit( symbol: impl Into<String>, qty: impl IntoQuantity, stop_price: Decimal, limit_price: Decimal, ) -> SingleOrderBuilder<Ready>

Equity stop-limit sell, default day order. Triggered when the market crosses stop_price, then becomes a limit order at limit_price.

pub fn buy_to_open_market( symbol: impl Into<String>, qty: impl IntoQuantity, ) -> SingleOrderBuilder<Ready>

Option buy-to-open at market, default day order. Opens a long option position.

pub fn buy_to_open_limit( symbol: impl Into<String>, qty: impl IntoQuantity, price: Decimal, ) -> SingleOrderBuilder<Ready>

Option buy-to-open at limit, default day order.

pub fn sell_to_open_market( symbol: impl Into<String>, qty: impl IntoQuantity, ) -> SingleOrderBuilder<Ready>

Option sell-to-open at market, default day order. Writes (shorts) an option.

pub fn sell_to_open_limit( symbol: impl Into<String>, qty: impl IntoQuantity, price: Decimal, ) -> SingleOrderBuilder<Ready>

Option sell-to-open at limit, default day order.

pub fn buy_to_close_market( symbol: impl Into<String>, qty: impl IntoQuantity, ) -> SingleOrderBuilder<Ready>

Option buy-to-close at market, default day order. Closes a previously written (short) option.

pub fn buy_to_close_limit( symbol: impl Into<String>, qty: impl IntoQuantity, price: Decimal, ) -> SingleOrderBuilder<Ready>

Option buy-to-close at limit, default day order.

pub fn sell_to_close_market( symbol: impl Into<String>, qty: impl IntoQuantity, ) -> SingleOrderBuilder<Ready>

Option sell-to-close at market, default day order. Closes a long option position.

pub fn sell_to_close_limit( symbol: impl Into<String>, qty: impl IntoQuantity, price: Decimal, ) -> SingleOrderBuilder<Ready>

Option sell-to-close at limit, default day order.

pub fn oco( child_a: impl Into<OrderRequest>, child_b: impl Into<OrderRequest>, ) -> OrderRequest

One-cancels-other: two child orders, the first to fill cancels the other. Top-level carries only orderStrategyType=OCO and the two children; each child is a complete order in its own right (typically a SINGLE).

Accepts either a finished OrderRequest or any SingleOrderBuilder<Ready>; the shortcuts and the explicit builder both satisfy impl Into<OrderRequest>.

The duration on each child controls how long that side stays live - for a take-profit + stop-loss pair you typically want both children set to Duration::GoodTillCancel via the builder.

Examples

A bracket exit: a take-profit limit paired with a stop-loss, first to fill cancels the other. Both children are good-till-cancel so neither expires at the close.

use rust_decimal_macros::dec;
use schwab_sdk::orders::{Duration, OrderRequest};

let take_profit = OrderRequest::single()
    .limit(dec!(15.27))
    .equity_sell("XYZ", dec!(5))
    .duration(Duration::GoodTillCancel)
    .build();
let stop_loss = OrderRequest::single()
    .stop(dec!(11.27))
    .equity_sell("XYZ", dec!(5))
    .duration(Duration::GoodTillCancel)
    .build();

let bracket = OrderRequest::oco(take_profit, stop_loss);

pub fn trigger( parent: impl Into<OrderRequest>, child: impl Into<OrderRequest>, ) -> OrderRequest

First-trigger-sequence: parent is the order Schwab places immediately; once it fills, child is released. The parent’s orderStrategyType is overwritten with TRIGGER.

Both arguments accept any impl Into<OrderRequest> - the shortcuts return a SingleOrderBuilder<Ready> which is converted transparently.

1st-Trigger-OCO is the composition OrderRequest::trigger(parent, OrderRequest::oco(profit, stop)).

Examples

Open a position, then attach a profit target and a stop once the entry fills (1st-trigger-OCO):

use rust_decimal_macros::dec;
use schwab_sdk::orders::{Duration, OrderRequest};

let entry = OrderRequest::buy_limit("XYZ", dec!(5), dec!(14.97));
let take_profit = OrderRequest::single()
    .limit(dec!(15.27))
    .equity_sell("XYZ", dec!(5))
    .duration(Duration::GoodTillCancel)
    .build();
let stop_loss = OrderRequest::single()
    .stop(dec!(11.27))
    .equity_sell("XYZ", dec!(5))
    .duration(Duration::GoodTillCancel)
    .build();

let order = OrderRequest::trigger(entry, OrderRequest::oco(take_profit, stop_loss));

Trait Implementations

impl Clone for OrderRequest

fn clone(&self) -> OrderRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OrderRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<SingleOrderBuilder<Ready>> for OrderRequest

fn from(builder: SingleOrderBuilder<Ready>) -> Self

Converts to this type from the input type.

impl Hash for OrderRequest

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for OrderRequest

fn eq(&self, other: &OrderRequest) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OrderRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Order> for OrderRequest

fn try_from(order: Order) -> Result<Self, Self::Error>

Convert a fetched Order into an OrderRequest body. Useful for constructing the body of a replace request from a previously-fetched order: take the live order, mutate the field(s) you want to change, and send it back.

Broker-assigned fields (orderId, status, enteredTime, cancelable, editable, fills, lineage, etc.) are not part of a request body and are dropped. Child strategies (OCO / TRIGGER) are converted recursively. Fields that cannot be represented in a request (a leg missing its instrument, an instrument missing its symbol) surface as Error::OrderResponseNotRepresentable.

type Error = Error

The type returned in the event of a conversion error.

impl Eq for OrderRequest

impl StructuralPartialEq for OrderRequest