Struct AlpacaBracketOrderRequest 

#[non_exhaustive]
pub struct AlpacaBracketOrderRequest {
    pub instrument: InstrumentNameExchange,
    pub strategy: StrategyId,
    pub cid: ClientOrderId,
    pub side: Side,
    pub quantity: Decimal,
    pub entry_price: Decimal,
    pub take_profit_price: Decimal,
    pub stop_loss_price: Decimal,
    pub stop_loss_limit_price: Option<Decimal>,
    pub time_in_force: TimeInForce,
}

Request to place a bracket order (entry + take-profit + stop-loss).

A bracket order consists of three linked orders submitted in a single request:

1. Entry: Limit order to enter the position
2. Take Profit: Limit order to exit at profit target
3. Stop Loss: Stop or stop-limit order to exit at loss limit

When either the take-profit or stop-loss fills, Alpaca automatically cancels the other leg.

Constraints

• time_in_force must be Day or GoodUntilCancelled (no extended hours)
• Entry order type is always Limit
• Take-profit is always a Limit order
• Stop-loss is a Stop order (or StopLimit if stop_loss_limit_price is set)

Example

let request = AlpacaBracketOrderRequest::new(
    "AAPL".into(),
    StrategyId::new("momentum"),
    ClientOrderId::new("bracket-001"),
    Side::Buy,
    dec!(10),
    dec!(150.00),  // entry
    dec!(160.00),  // take profit
    dec!(145.00),  // stop loss
    TimeInForce::GoodUntilCancelled { post_only: false },
);
// For stop-limit SL: .with_stop_loss_limit_price(dec!(144.00))
let result = client.open_bracket_order(request).await;

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

instrument: InstrumentNameExchange

Instrument to trade.

strategy: StrategyId

Strategy identifier for order correlation.

cid: ClientOrderId

Client order ID for the parent (entry) order.

side: Side

Buy or Sell for the entry order (exits use opposite side).

quantity: Decimal

Number of shares/contracts.

entry_price: Decimal

Entry limit price.

take_profit_price: Decimal

Take-profit limit price.

stop_loss_price: Decimal

Stop-loss trigger price.

stop_loss_limit_price: Option<Decimal>

Optional stop-loss limit price. When set, makes the stop-loss a stop-limit order.

time_in_force: TimeInForce

Time-in-force for all legs. Must be Day or GoodUntilCancelled.

Implementations

impl AlpacaBracketOrderRequest

pub fn new( instrument: InstrumentNameExchange, strategy: StrategyId, cid: ClientOrderId, side: Side, quantity: Decimal, entry_price: Decimal, take_profit_price: Decimal, stop_loss_price: Decimal, time_in_force: TimeInForce, ) -> Self

Create a new bracket order request.

For a stop-limit stop-loss leg, chain .with_stop_loss_limit_price().

pub fn with_stop_loss_limit_price(self, price: Decimal) -> Self

Set the stop-loss limit price, converting the SL leg to a stop-limit order.

Trait Implementations

impl Clone for AlpacaBracketOrderRequest

fn clone(&self) -> AlpacaBracketOrderRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AlpacaBracketOrderRequest

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

Formats the value using the given formatter.