@0xmonaco/types 1.0.46 → 1.0.48

package/dist/margin-accounts/index.d.ts

@@ -32,6 +32,42 @@ export interface MarginAccountSummary {
     unrealizedPnl: string;
     realizedPnl: string;
     updatedAt: string;
+    /**
+     * The collateral still available to open NEW orders in this risk bucket:
+     * the largest increase in the bucket's worst-case order reserve the risk
+     * engine's admission gate accepts, automatic top-up from the parent margin
+     * account's unallocated capacity included. Zero while the account or bucket
+     * is frozen for liquidation, and for an isolated bucket whose market is
+     * halted (a cross bucket's market is chosen per order, so a halt cannot be
+     * folded into its figure — a halted pair still refuses orders).
+     *
+     * The trading-side sibling of `withdrawableCollateral`, and deliberately a
+     * different figure: this one credits an unrealized gain in full, because a
+     * gain is legitimate initial margin for new positions, while a withdrawal
+     * never counts one. It already contains the bucket's live free collateral —
+     * do not add `freeCollateral` or `unrealizedPnl` on top. It can also
+     * legitimately differ from this row's `freeCollateral`, a persisted
+     * reconstruction that cannot see the engine's worst-case resting-order
+     * reserve.
+     *
+     * NOT additive across rows: every bucket's figure includes the SAME parent
+     * unallocated headroom, so summing rows multiply-counts it, and committing
+     * collateral in one bucket shrinks its siblings' figures.
+     *
+     * This is a requirement budget, not an order size: an order is charged the
+     * increase it causes in the bucket's worst-case per-pair reserve, so a
+     * reducing, reduce-only, or opposite-side order sheltered by a larger
+     * resting ladder needs less or none of it (and can be admitted even when
+     * this field is zero), while an order crossing a losing position can need
+     * more than its own margin-plus-fee. Divide by a market's initial margin
+     * rate for indicative notional capacity; the authoritative per-order answer
+     * remains `simulateRiskBucketOrderRisk`.
+     *
+     * Present only on risk-bucket rows served from a live risk engine snapshot;
+     * absent (the key is omitted, never null) on parent rows and on
+     * persisted-fallback reads.
+     */
+    availableOrderCollateral?: string;
 }
 export interface ListMarginAccountsParams {
     page?: number;

package/dist/portfolio/index.d.ts

@@ -203,6 +203,18 @@ export interface PortfolioRiskBucket {
      * partial withdrawals below it.
      */
     withdrawableCollateral: string;
+    /**
+     * The collateral still available to open NEW orders in this risk bucket —
+     * the same engine-served admission bound as
+     * `MarginAccountSummary.availableOrderCollateral` (see that field for the
+     * full semantics: an envelope delta with parent auto top-up included, NOT
+     * additive across rows, zero while frozen), truncated toward zero at quote
+     * decimals like `withdrawableCollateral` beside it.
+     *
+     * Present only when a live risk engine snapshot served the bound; absent
+     * (the key is omitted, never null) on persisted-fallback reads.
+     */
+    availableOrderCollateral?: string;
 }
 export interface PortfolioMargin {
     asOf: string;

package/dist/sdk/index.d.ts

@@ -1,11 +1,11 @@
 import type { Address, PublicClient, TransactionReceipt, WalletClient } from "viem";
 import type { ApplicationsAPI } from "../applications";
-import type { AuthAPI, AuthState, SessionCredentials } from "../auth/index";
+import type { AuthAPI, AuthState } from "../auth/index";
 import type { DelegatedAgentsAPI } from "../delegated-agents";
 import type { FaucetAPI } from "../faucet";
 import type { FeesAPI } from "../fees";
 import type { MarginAccountsAPI } from "../margin-accounts";
-import type { Interval, MarketAPI } from "../market";
+import type { MarketAPI } from "../market";
 import type { PitpassAPI } from "../pitpass";
 import type { PortfolioAPI } from "../portfolio";
 import type { PositionsAPI } from "../positions";
@@ -15,7 +15,7 @@ import type { SubAccountsAPI } from "../sub-accounts";
 import type { SweeperAPI } from "../sweeper";
 import type { TradingAPI, TradingMode } from "../trading";
 import type { VaultAPI } from "../vault";
-import type { ConditionalOrderEvent, MonacoWebSocketConfig, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, TradeEvent, TwapOrderEvent, UserBalanceEvent, UserMovementEvent } from "../websocket";
+import type { MonacoWebSocket, MonacoWebSocketConfig, OrderbookEvent, OrderbookQuotationMode, TradeEvent } from "../websocket";
 import type { WhitelistAPI } from "../whitelist";
 import type { WithdrawalsAPI } from "../withdrawals";
 import type { Network } from "./network";
@@ -139,23 +139,8 @@ export interface MonacoSDK {
             pageSize?: number;
         }) => Promise<TradeEvent[]>;
     };
-    /** WebSocket client for real-time data (orders, orderbook, ohlcv) */
-    ws: {
-        connect: () => Promise<void>;
-        disconnect: () => void;
-        isConnected: () => boolean;
-        getStatus: () => "connected" | "connecting" | "disconnected" | "reconnecting";
-        setSessionKeypair: (credentials: SessionCredentials | undefined) => void;
-        orders: (tradingPairId: string, tradingMode: TradingMode, handler: (event: OrderEvent) => void) => () => void;
-        orderbook: (tradingPairId: string, tradingMode: TradingMode, magnitude: number, quotationMode: OrderbookQuotationMode, handler: (event: OrderbookEvent) => void) => () => void;
-        ohlcv: (tradingPairId: string, tradingMode: TradingMode, interval: Interval, handler: (event: OHLCVEvent) => void) => () => void;
-        trades: (tradingPairId: string, handler: (event: TradeEvent) => void) => () => void;
-        movements: (handler: (event: UserMovementEvent) => void) => () => void;
-        userOrders: (handler: (event: OrderEvent) => void) => () => void;
-        balances: (handler: (event: UserBalanceEvent) => void) => () => void;
-        conditionalOrders: (handler: (event: ConditionalOrderEvent) => void, tradingPairId?: string) => () => void;
-        twapOrders: (handler: (event: TwapOrderEvent) => void, tradingPairId?: string) => () => void;
-    };
+    /** WebSocket client for real-time data — the full typed channel surface of {@link MonacoWebSocket} */
+    ws: MonacoWebSocket;
     /** Wallet client for all blockchain operations (undefined until set) */
     walletClient: WalletClient | undefined;
     /** Public client for read-only blockchain operations */

package/dist/trading/index.d.ts

@@ -48,8 +48,11 @@ export interface TradingAPI extends BaseAPI {
         /**
          * Client-assigned correlation handle, echoed back on order reads and
          * order WebSocket events. At most 64 characters from [A-Za-z0-9._:-].
-         * Not de-duplicated and not unique — a replacement re-states it and
-         * inherits nothing from the original order.
+         * Uniqueness is enforced only among your orders that are resting on the
+         * book; an order that never rests does not take the handle, and the value
+         * is released on any terminal state. It does not make a retry safe —
+         * resubmitting after a lost response can execute a second time. A
+         * replacement re-states it and inherits nothing from the original order.
          */
         clientOrderId?: string;
         takeProfit?: ParentTpSlLegParams;
@@ -80,8 +83,11 @@ export interface TradingAPI extends BaseAPI {
         /**
          * Client-assigned correlation handle, echoed back on order reads and
          * order WebSocket events. At most 64 characters from [A-Za-z0-9._:-].
-         * Not de-duplicated and not unique — a replacement re-states it and
-         * inherits nothing from the original order.
+         * Uniqueness is enforced only among your orders that are resting on the
+         * book; an order that never rests does not take the handle, and the value
+         * is released on any terminal state. It does not make a retry safe —
+         * resubmitting after a lost response can execute a second time. A
+         * replacement re-states it and inherits nothing from the original order.
          */
         clientOrderId?: string;
         takeProfit?: ParentTpSlLegParams;
@@ -142,8 +148,14 @@ export interface TradingAPI extends BaseAPI {
         /**
          * Client-assigned correlation handle, echoed back on order reads and
          * order WebSocket events. At most 64 characters from [A-Za-z0-9._:-].
-         * Not de-duplicated and not unique — a replacement re-states it and
-         * inherits nothing from the original order.
+         * Uniqueness is enforced only among your orders that are resting on the
+         * book; an order that never rests does not take the handle, and the value
+         * is released on any terminal state. A replacement re-states it and
+         * inherits nothing from the original order. A retry of this replace cannot
+         * double-execute — it names the original order id, which the engine
+         * revalidates at sequence time, so a second attempt returns
+         * ORDER_NOT_FOUND — but that code is ambiguous on its own, so reconcile to
+         * find the replacement's new order id rather than to rule out a duplicate.
          */
         clientOrderId?: string;
     }): Promise<ReplaceOrderResponse>;
@@ -222,6 +234,6 @@ export interface TradingAPI extends BaseAPI {
      */
     listTwapOrders(params?: ListTwapOrdersParams): Promise<ListTwapOrdersResponse>;
 }
-export type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderRole, OrderSide, OrderStatus, OrderStatusFilter, OrderTerminalReason, OrderType, PositionSide, TimeInForce, TradingMode, TwapOrderState, } from "./orders";
+export type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderRole, OrderSide, OrderStatus, OrderStatusFilter, OrderTerminalReason, OrderType, PositionSide, TimeInForce, TradingMode, TwapExecutionStyle, TwapOrderState, } from "./orders";
 export { ORDER_STATUS_VALUES } from "./orders";
 export type { BatchCancelError, BatchCancelOrdersResponse, BatchCancelResult, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchCreateResult, BatchError, BatchReplaceOrderParams, BatchReplaceOrdersResponse, BatchReplaceResult, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MatchResult, ParentTpSlLegParams, ReplaceOrderResponse, TwapOrder, UpdatedFields, } from "./responses";

package/dist/trading/orders.d.ts

@@ -74,8 +74,10 @@ export interface Order {
      * Client-assigned correlation handle as stored: the value supplied on create
      * or replace, with surrounding whitespace trimmed. Absent when the order
      * carried none, including every order placed before the field was accepted on
-     * write. Not unique — several orders may share one value, so a lookup by it
-     * can be ambiguous.
+     * write. Uniqueness is enforced only among your orders that are resting on
+     * the book, so several of your orders may share one value over time and a
+     * lookup by it can be ambiguous: an order that never rests never takes the
+     * handle, and the value is released on any terminal state.
      */
     clientOrderId?: string;
     /** Position ID linked to the order, when available */
@@ -168,3 +170,10 @@ export type ConditionalOrderState = "PENDING_PARENT" | "ACTIVE" | "TRIGGERING" |
  * - CANCELLED: cancelled by the user before the window ended
  */
 export type TwapOrderState = "PENDING" | "ACTIVE" | "COMPLETED" | "CANCELLED";
+/**
+ * How a TWAP parent executes each slice.
+ * - TAKER (default): banded MARKET slices fired at each slot
+ * - PASSIVE: post-only children rested at the touch, with a taker sweep at
+ *   each slice deadline
+ */
+export type TwapExecutionStyle = "TAKER" | "PASSIVE";

package/dist/trading/responses.d.ts

@@ -4,7 +4,7 @@
  * Response types for trading operations.
  */
 import type { MarginMode } from "../margin-accounts";
-import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderSide, OrderStatus, OrderStatusFilter, OrderType, PositionSide, TimeInForce, TradingMode, TwapOrderState } from "./orders";
+import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderSide, OrderStatus, OrderStatusFilter, OrderType, PositionSide, TimeInForce, TradingMode, TwapExecutionStyle, TwapOrderState } from "./orders";
 /**
  * Match result information for order execution.
  * Contains detailed information about trades, fills, and execution quality.
@@ -378,8 +378,11 @@ export interface BatchCreateOrderParams {
     /**
      * Client-assigned correlation handle, echoed back on order reads and on
      * order WebSocket events. At most 64 characters from [A-Za-z0-9._:-].
-     * Monaco does not de-duplicate on it and does not enforce uniqueness —
-     * it correlates a response to a request, it does not make a retry safe.
+     * Uniqueness is enforced only among your orders that are resting on the
+     * book; an order that never rests does not take the handle, and the value
+     * is released on any terminal state. It correlates a response to a request
+     * and does not make a retry safe — resubmitting after a lost response can
+     * execute a second time.
      */
     clientOrderId?: string;
 }
@@ -403,8 +406,13 @@ export interface BatchReplaceOrderParams {
     /**
      * Client-assigned correlation handle, echoed back on order reads and on
      * order WebSocket events. At most 64 characters from [A-Za-z0-9._:-].
-     * Monaco does not de-duplicate on it and does not enforce uniqueness —
-     * it correlates a response to a request, it does not make a retry safe.
+     * Uniqueness is enforced only among your orders that are resting on the
+     * book; an order that never rests does not take the handle, and the value
+     * is released on any terminal state. It correlates a response to a request.
+     * Each item names its own original order id, which the engine revalidates at
+     * sequence time, so retrying a batch cannot replace an already-replaced
+     * original a second time; reconcile per item on the results and their new
+     * order ids rather than to rule out duplicate execution.
      */
     clientOrderId?: string;
 }
@@ -491,6 +499,15 @@ export interface CreateTwapOrderOptions {
      * reproducible to compliance but unpredictable to the market.
      */
     randomize?: boolean;
+    /**
+     * Child execution style. "TAKER" (default): each slice executes
+     * immediately as a banded MARKET order. "PASSIVE": each slice rests as a
+     * post-only limit at the same-side touch (maker where possible, repriced
+     * to follow the touch), and the leftover is swept as a banded MARKET order
+     * at the slice deadline; passive parents use a slower default slice
+     * cadence (~60s).
+     */
+    executionStyle?: "TAKER" | "PASSIVE";
     /** Whether the TWAP parent is reduce-only (margin only). Child orders inherit it and clamp to the live position. */
     reduceOnly?: boolean;
     /** Trading mode: "SPOT" or "MARGIN" (default: "SPOT"). */
@@ -507,6 +524,23 @@ export interface CreateTwapOrderOptions {
     strategyKey?: string;
     /** Use master account balance for sub-account orders. */
     useMasterBalance?: boolean;
+    /**
+     * Price-triggered activation: the parent waits (PENDING) until the
+     * reference price reaches or crosses this price in `triggerDirection`,
+     * then runs a floating window of `durationSeconds` from the trigger
+     * instant. Requires `triggerDirection` and `durationSeconds`; incompatible
+     * with `startTime`/`endTime`. Rejected if already met at creation.
+     */
+    triggerPrice?: string;
+    /** Crossing direction for `triggerPrice`: "ABOVE" or "BELOW". Required with `triggerPrice`. */
+    triggerDirection?: "ABOVE" | "BELOW";
+    /**
+     * Deadline for the trigger to fire (RFC 3339, UTC only — Z suffix). If it
+     * has not fired by then the parent cancels with terminal reason
+     * 'trigger expired'. Only valid with `triggerPrice`; defaults to creation
+     * + the maximum window (30 days).
+     */
+    conditionalExpiry?: string;
     /** Client-assigned idempotency key (max 36 chars), unique per user and application. A duplicate is rejected with 409. */
     clientTwapId?: string;
 }
@@ -589,6 +623,8 @@ export interface TwapOrder {
     clientTwapId?: string;
     /** Whether seeded size/timing randomization is applied to the schedule */
     randomize: boolean;
+    /** Child execution style: "TAKER" (banded MARKET slices) or "PASSIVE" (post-only children at the touch, taker sweep at each slice deadline) */
+    executionStyle: TwapExecutionStyle;
     /** Window start (ISO 8601) */
     startTime: string;
     /** Window end (ISO 8601). Execution stops hard at this time. */
@@ -611,6 +647,14 @@ export interface TwapOrder {
     state: TwapOrderState;
     /** Terminal cause detail, e.g. an end-of-window shortfall ('ended with shortfall <qty>'); absent for non-terminal parents */
     terminalReason?: string;
+    /** Price-triggered activation level, when this parent is conditional */
+    triggerPrice?: string;
+    /** Trigger crossing direction: "ABOVE" or "BELOW" */
+    triggerDirection?: string;
+    /** Deadline for the trigger to fire (ISO 8601 UTC); reaching it cancels the parent ('trigger expired') */
+    conditionalExpiry?: string;
+    /** When the trigger fired and the floating window started (ISO 8601 UTC); absent while waiting */
+    triggeredAt?: string;
     /** Creation timestamp (ISO 8601) */
     createdAt: string;
     /** Last update timestamp (ISO 8601) */

package/dist/validation/trading.d.ts

@@ -331,12 +331,6 @@ export declare const TwapOrderStateSchema: z.ZodEnum<{
     PENDING: "PENDING";
     COMPLETED: "COMPLETED";
 }>;
-/**
- * Create TWAP Order validation schema
- *
- * Validates parameters for creating a TWAP parent order. The execution
- * window is mandatory: exactly one of durationSeconds or endTime.
- */
 export declare const CreateTwapOrderSchema: z.ZodObject<{
     tradingPairId: z.ZodUUID;
     side: z.ZodEnum<{
@@ -351,6 +345,10 @@ export declare const CreateTwapOrderSchema: z.ZodObject<{
         limitPrice: z.ZodOptional<z.ZodString>;
         slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
         randomize: z.ZodOptional<z.ZodBoolean>;
+        executionStyle: z.ZodOptional<z.ZodEnum<{
+            TAKER: "TAKER";
+            PASSIVE: "PASSIVE";
+        }>>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
         tradingMode: z.ZodOptional<z.ZodEnum<{
             SPOT: "SPOT";
@@ -366,6 +364,12 @@ export declare const CreateTwapOrderSchema: z.ZodObject<{
         strategyKey: z.ZodOptional<z.ZodString>;
         useMasterBalance: z.ZodOptional<z.ZodBoolean>;
         clientTwapId: z.ZodOptional<z.ZodString>;
+        triggerPrice: z.ZodOptional<z.ZodString>;
+        triggerDirection: z.ZodOptional<z.ZodEnum<{
+            ABOVE: "ABOVE";
+            BELOW: "BELOW";
+        }>>;
+        conditionalExpiry: z.ZodOptional<z.ZodISODateTime>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const CancelTwapOrderSchema: z.ZodObject<{

package/dist/validation/trading.js

@@ -386,6 +386,8 @@ const TwapDurationSecondsSchema = z.union([
  * Validates parameters for creating a TWAP parent order. The execution
  * window is mandatory: exactly one of durationSeconds or endTime.
  */
+/** Maximum TWAP window, and therefore the cap on `conditionalExpiry` (30 days). */
+const MAX_TWAP_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
 export const CreateTwapOrderSchema = z
     .object({
     tradingPairId: UUIDSchema,
@@ -398,6 +400,7 @@ export const CreateTwapOrderSchema = z
         limitPrice: PositiveDecimalStringSchema.optional(),
         slippageToleranceBps: TwapSlippageToleranceBpsSchema.optional(),
         randomize: z.boolean().optional(),
+        executionStyle: z.enum(["TAKER", "PASSIVE"]).optional(),
         reduceOnly: z.boolean().optional(),
         tradingMode: TradingModeSchema.optional(),
         marginAccountId: UUIDSchema.optional(),
@@ -407,6 +410,9 @@ export const CreateTwapOrderSchema = z
         strategyKey: z.string().min(1).max(128).optional(),
         useMasterBalance: z.boolean().optional(),
         clientTwapId: z.string().min(1).max(36, "clientTwapId cannot exceed 36 characters").optional(),
+        triggerPrice: PositiveDecimalStringSchema.optional(),
+        triggerDirection: z.enum(["ABOVE", "BELOW"]).optional(),
+        conditionalExpiry: ISO8601DateSchema.optional(),
     }),
 })
     .refine((data) => (data.options.durationSeconds !== undefined) !== (data.options.endTime !== undefined), {
@@ -436,6 +442,48 @@ export const CreateTwapOrderSchema = z
     .refine((data) => data.options.tradingMode !== "MARGIN" || data.options.reduceOnly === true || data.options.leverage !== undefined, {
     message: "leverage is required for normal MARGIN TWAP orders",
     path: ["options", "leverage"],
+})
+    .refine((data) => (data.options.triggerPrice !== undefined) === (data.options.triggerDirection !== undefined), {
+    message: "triggerPrice and triggerDirection are both-or-neither",
+    path: ["options", "triggerDirection"],
+})
+    .refine((data) => data.options.triggerPrice === undefined || data.options.durationSeconds !== undefined, {
+    message: "conditional TWAP (triggerPrice) requires durationSeconds — the window floats from the trigger instant",
+    path: ["options", "durationSeconds"],
+})
+    .refine((data) => data.options.triggerPrice === undefined || (data.options.startTime === undefined && data.options.endTime === undefined), {
+    message: "triggerPrice is incompatible with startTime/endTime",
+    path: ["options", "triggerPrice"],
+})
+    .refine((data) => data.options.conditionalExpiry === undefined || data.options.triggerPrice !== undefined, {
+    message: "conditionalExpiry is only valid together with triggerPrice",
+    path: ["options", "conditionalExpiry"],
+})
+    // The two VALUE rules on conditionalExpiry, mirroring the server. Without
+    // them the schema only checks the timestamp's shape and every deadline in
+    // the past — or beyond the maximum window — round-trips to a 400. The
+    // UTC-suffix rule stays server-side: ISO8601DateSchema deliberately accepts
+    // any valid offset, and narrowing it here would change an unrelated shared
+    // schema.
+    .refine((data) => {
+    const raw = data.options.conditionalExpiry;
+    if (raw === undefined)
+        return true;
+    const at = Date.parse(raw);
+    return Number.isNaN(at) || at > Date.now();
+}, {
+    message: "conditionalExpiry must be in the future",
+    path: ["options", "conditionalExpiry"],
+})
+    .refine((data) => {
+    const raw = data.options.conditionalExpiry;
+    if (raw === undefined)
+        return true;
+    const at = Date.parse(raw);
+    return Number.isNaN(at) || at - Date.now() <= MAX_TWAP_WINDOW_MS;
+}, {
+    message: "conditionalExpiry cannot be more than 30 days after creation (the maximum window)",
+    path: ["options", "conditionalExpiry"],
 });
 export const CancelTwapOrderSchema = z.object({
     twapOrderId: UUIDSchema,

package/dist/websocket/client.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Monaco WebSocket client surface.
+ *
+ * The canonical, hand-written subscription interface implemented by
+ * `@0xmonaco/core`'s `createMonacoWebSocket` and exposed as `MonacoSDK.ws`.
+ * It lives here (not in `@0xmonaco/core`) so every package types the same
+ * surface — the channel-coverage lock in
+ * `tests/websocket/channel-coverage.test.ts` parses this file as the source
+ * of truth for the SDK's channel surface.
+ */
+import type { SessionCredentials } from "../auth/index";
+import type { Interval } from "../market";
+import type { TradingMode } from "../trading";
+import type { WebSocketStatus } from "./base";
+import type { OrderbookQuotationMode } from "./clients/orderbook-client";
+import type { AccountEvent, ConditionalOrderEvent, InstrumentEvent, LiquidationEvent, MarketStatsAllEvent, MarketStatsEvent, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, TradeEvent, TwapOrderEvent, UserBalanceEvent, UserMovementEvent } from "./events";
+export type MessageHandler<T> = (data: T) => void;
+export interface MonacoWebSocket {
+    /** Connect to the WebSocket server */
+    connect: () => Promise<void>;
+    /** Disconnect from the WebSocket server */
+    disconnect: () => void;
+    /** Check if currently connected */
+    isConnected: () => boolean;
+    /** Get current websocket connection status */
+    getStatus: () => WebSocketStatus;
+    /** Set (or clear) the session keypair used to authenticate the connection */
+    setSessionKeypair: (credentials: SessionCredentials | undefined) => void;
+    /** Subscribe to order events (requires authentication) */
+    orders: (tradingPairId: string, tradingMode: TradingMode, handler: MessageHandler<OrderEvent>) => () => void;
+    /** Subscribe to orderbook events (public) */
+    orderbook: (tradingPairId: string, tradingMode: TradingMode, magnitude: number, quotationMode: OrderbookQuotationMode, handler: MessageHandler<OrderbookEvent>) => () => void;
+    /** Subscribe to OHLCV candlestick events (public) */
+    ohlcv: (tradingPairId: string, tradingMode: TradingMode, interval: Interval, handler: MessageHandler<OHLCVEvent>, priceType?: OHLCVPriceType) => () => void;
+    /** Subscribe to trade events (public) */
+    trades: (tradingPairId: string, handler: MessageHandler<TradeEvent>) => () => void;
+    /** Subscribe to user movement events (requires authentication) */
+    movements: (handler: MessageHandler<UserMovementEvent>) => () => void;
+    /** Subscribe to user order events for all trading pairs (requires authentication) */
+    userOrders: (handler: MessageHandler<OrderEvent>) => () => void;
+    /** Subscribe to user balance events (requires authentication) */
+    balances: (handler: MessageHandler<UserBalanceEvent>) => () => void;
+    /** Subscribe to conditional TP/SL lifecycle events (requires authentication) */
+    conditionalOrders: (handler: MessageHandler<ConditionalOrderEvent>, tradingPairId?: string) => () => void;
+    /** Subscribe to TWAP parent-order lifecycle events (requires authentication) */
+    twapOrders: (handler: MessageHandler<TwapOrderEvent>, tradingPairId?: string) => () => void;
+    /** Subscribe to position state updates (requires authentication); omit `tradingPairId` for all pairs */
+    positions: (handler: MessageHandler<PositionEvent>, tradingPairId?: string) => () => void;
+    /** Subscribe to liquidation alerts (requires authentication); omit `tradingPairId` for all pairs */
+    liquidations: (handler: MessageHandler<LiquidationEvent>, tradingPairId?: string) => () => void;
+    /** Subscribe to account-level margin health updates for the authenticated user (requires authentication) */
+    account: (handler: MessageHandler<AccountEvent>) => () => void;
+    /** Subscribe to market lifecycle + config changes (public); omit `tradingPairId` for all markets */
+    instruments: (handler: MessageHandler<InstrumentEvent>, tradingPairId?: string) => () => void;
+    /** Subscribe to per-market statistics for one trading pair (public) */
+    marketStats: (tradingPairId: string, handler: MessageHandler<MarketStatsEvent>) => () => void;
+    /** Subscribe to the all-markets statistics summary (public) */
+    marketStatsAll: (handler: MessageHandler<MarketStatsAllEvent>) => () => void;
+}

package/dist/websocket/client.js

@@ -0,0 +1,10 @@
+/**
+ * Monaco WebSocket client surface.
+ *
+ * The canonical, hand-written subscription interface implemented by
+ * `@0xmonaco/core`'s `createMonacoWebSocket` and exposed as `MonacoSDK.ws`.
+ * It lives here (not in `@0xmonaco/core`) so every package types the same
+ * surface — the channel-coverage lock in
+ * `tests/websocket/channel-coverage.test.ts` parses this file as the source
+ * of truth for the SDK's channel surface.
+ */

package/dist/websocket/events/account-events.d.ts

@@ -16,6 +16,24 @@
 export interface AccountEventData {
     /** Margin account this update describes (UUID) */
     marginAccountId: string;
+    /**
+     * Monotonic per-account counter within one producer run. It advances only on
+     * published frames, may SKIP values (at-most-once delivery, conflation), and
+     * resets to zero when the producer restarts — which can happen while your
+     * WebSocket stays connected, because the socket is owned by a different
+     * service. It is therefore never a gap detector and never a cross-restart
+     * total order.
+     *
+     * Dedupe rule: order frames per account by `updatedAt`, newest wins; use
+     * `sequence` only to break ties between frames carrying the SAME `updatedAt`
+     * (those come from the same producer run).
+     *
+     * There is no subscribe-time snapshot: an account with active exposure
+     * delivers a baseline within ~30s (keepalive republish), but a FLAT account
+     * is silent until it re-activates — fetch the margin-accounts REST endpoint
+     * when an immediate flat baseline is needed.
+     */
+    sequence: number;
     /** Mark-inclusive account equity: collateral + unrealized PnL + funding (decimal string) */
     equity: string;
     /** Raw deposited collateral in USD (decimal string) */

package/dist/websocket/events/conditional-order-events.d.ts

@@ -1,5 +1,35 @@
 import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, OrderSide, OrderType, PositionSide, TimeInForce } from "../../trading";
+/**
+ * The canonical `reason` values carried by a **live** conditional-order update.
+ *
+ * Not the complete set of strings the field can hold: the subscribe-time
+ * snapshot reuses this same data shape with the literal `"snapshot"`, and the
+ * wire field is a free-form server string rather than a closed enum, so this
+ * alias is documentation and a narrowing aid only. Match on it with a default
+ * branch; see `ConditionalOrderEventData.reason`.
+ */
 export type ConditionalOrderEventReason = "created" | "activated" | "cancelled" | "parent_cancelled" | "triggered" | "failed" | "oco_cancelled";
+/**
+ * A conditional (TP/SL) order's current state.
+ *
+ * **The value unions below are the values the server can send today, not a
+ * runtime guarantee.** `@0xmonaco/core` parses this frame leniently — an
+ * unrecognized `orderType`, `state`, `side`, `positionSide`, `conditionType`,
+ * `triggerSource`, `associationType` or `timeInForce` is passed through as-is
+ * rather than validated, because throwing inside the WebSocket message handler
+ * would drop the entire update with nothing surfaced to the consumer
+ * (0XM-2627). Most of these unions mirror an exhaustive server-side mapping, so
+ * a value outside one means the server gained a variant this SDK version
+ * predates. `orderType` is the exception — its mapping ends in a catch-all arm,
+ * so its completeness rests on producer validation instead; see that field's
+ * own note.
+ *
+ * Consequently: match on these fields with a `default` branch rather than
+ * relying on exhaustiveness, exactly as you would for the free-form `reason`.
+ * A dropped frame is a worse failure than an unhandled value, so the parser
+ * chooses the latter — the same trade the position, liquidation and
+ * market-stats parsers already make.
+ */
 export interface ConditionalOrderEventData {
     conditionalOrderId: string;
     tradingPairId: string;
@@ -13,12 +43,35 @@ export interface ConditionalOrderEventData {
     triggerPrice: string;
     side: OrderSide;
     positionSide: PositionSide;
+    /**
+     * Order shape the conditional order places when it triggers.
+     *
+     * `LIMIT` and `MARKET` are the complete set: both creation paths reject
+     * anything else — `orderType must be MARKET or LIMIT` from the TP/SL handler
+     * and `parent TP/SL order_type must be MARKET or LIMIT` from the matching
+     * engine's leg-shape check. The other server-side `OrderType` variants
+     * cannot reach this event.
+     *
+     * Unlike the other fields here, that rests on validation rather than on an
+     * exhaustive mapping: the server's `order_type` arm ends in a catch-all that
+     * Debug-formats and uppercases the variant, so were validation ever relaxed
+     * the value would arrive as e.g. `STOPLOSS` rather than the canonical
+     * `STOP_LOSS`. The parser passes such a value through untouched.
+     */
     orderType: OrderType;
     limitPrice?: string;
     quantity?: string;
     slippageToleranceBps?: number;
     reduceOnly: boolean;
-    timeInForce?: Extract<TimeInForce, "GTC" | "IOC">;
+    /**
+     * Time in force for a `LIMIT` conditional order; absent for `MARKET`.
+     *
+     * The full `TimeInForce` enum, not the `GTC`/`IOC` subset the creation paths
+     * validate: this field mirrors an unconstrained `time_in_force` column that
+     * the server maps exhaustively over every variant, so a value written by any
+     * other path reaches the wire as-is. Narrow before relying on the subset.
+     */
+    timeInForce?: TimeInForce;
     state: ConditionalOrderState;
     triggeredOrderId?: string;
     triggeredAt?: string;
@@ -26,7 +79,13 @@ export interface ConditionalOrderEventData {
     cancelledAt?: string;
     expiresAt?: string;
     failureReason?: string;
-    reason: ConditionalOrderEventReason;
+    /**
+     * What produced this update. Free-form on the wire — the server field is a
+     * plain string, not an enum — but a live update's canonical values are the
+     * ones listed on {@link ConditionalOrderEventReason}. The subscribe-time
+     * snapshot builds the same shape with `"snapshot"` instead.
+     */
+    reason: string;
     updatedAt: string;
 }
 export interface ConditionalOrderEvent {

package/dist/websocket/events/orders-events.d.ts

@@ -62,10 +62,21 @@ export interface CommonOrderEventData {
     /**
      * Client-assigned correlation handle, echoed so an event can be matched to
      * the request that placed the order without a round trip to `getOrder`.
-     * Carried on every order event that inherits these fields — placed, taker and
-     * maker fills, cancelled, rejected and expired — so a submit whose HTTP
-     * response was lost can be resolved from the stream alone. Omitted when the
-     * order carried none. Wire: `client_order_id`.
+     * Carried on every order event that inherits these fields — the `OrderPlaced`
+     * acknowledgement, taker and maker fills, cancellation, expiry, and the
+     * `OrderRejected` raised after acceptance — an IOC/FOK that cannot fill, or a
+     * MARKET order whose apparent liquidity is invalidated by maker-risk
+     * revalidation — so a matching event is positive proof that a submit whose HTTP
+     * response was lost did land. Two separate caveats: a create rejected *before* acceptance
+     * (malformed, post-only would cross, handle conflict, a plain MARKET submit
+     * with no liquidity) emits no event at all; and the stream is not replayable, so a subscription opened
+     * late or gapped misses events it would otherwise have carried — and because
+     * the fan-out is non-persistent Core NATS, the service can re-establish an
+     * ended upstream subscription without closing your socket, so events can be
+     * missed while the connection still looks healthy. A matching event is
+     * positive proof the order was accepted; silence is NEVER evidence it was
+     * not, and no client-observable condition makes it so. Never resubmit on
+     * silence. Omitted when the order carried none. Wire: `client_order_id`.
      */
     clientOrderId?: string;
 }

package/dist/websocket/events/twap-order-events.d.ts

@@ -1,8 +1,14 @@
-import type { OrderSide, TradingMode, TwapOrderState } from "../../trading";
+import type { OrderSide, TradingMode, TwapExecutionStyle, TwapOrderState } from "../../trading";
 /**
  * Mutation that produced a TWAP parent-order snapshot.
+ *
+ * PASSIVE-style parents add three reasons: `passive_child_placed` (a
+ * post-only child now rests at the touch), `child_repriced` (the resting
+ * child atomically moved to the new touch), and `passive_fill` (maker fills
+ * on the resting child folded into the parent). Taker sweeps and crossing
+ * takes surface as the existing `slice_placed`.
  */
-export type TwapOrderEventReason = "created" | "slice_placed" | "slice_skipped" | "cancelled" | "completed";
+export type TwapOrderEventReason = "created" | "slice_placed" | "slice_skipped" | "passive_child_placed" | "child_repriced" | "passive_fill" | "cancelled" | "completed" | "triggered" | "trigger_expired";
 /**
  * TWAP parent-order snapshot carried by a `twap_orders` WebSocket event.
  * The server publishes the full read model on every lifecycle transition
@@ -34,6 +40,8 @@ export interface TwapOrderEventData {
     strategyKey?: string;
     clientTwapId?: string;
     randomize: boolean;
+    /** Child execution style: "TAKER" (banded MARKET slices) or "PASSIVE" (post-only children at the touch, taker sweep at each slice deadline) */
+    executionStyle: TwapExecutionStyle;
     /** Window start (ISO 8601) */
     startAt: string;
     /** Window end (ISO 8601). Execution stops hard at this time. */
@@ -50,6 +58,12 @@ export interface TwapOrderEventData {
     state: TwapOrderState;
     /** Terminal annotation, e.g. "ended with shortfall 1.5"; absent for non-terminal parents */
     terminalReason?: string;
+    /** Conditional configuration + activation stamp (parity with the REST read
+     * model). All absent on unconditional parents. */
+    triggerPrice?: string;
+    triggerDirection?: "ABOVE" | "BELOW";
+    conditionalExpiry?: string;
+    triggeredAt?: string;
     createdAt: string;
     updatedAt: string;
     cancelledAt?: string;

package/dist/websocket/index.d.ts

@@ -4,5 +4,6 @@
  * Fundamental definitions for Websocket connections, errors and events.
  */
 export * from "./base";
+export * from "./client";
 export * from "./clients/orderbook-client";
 export * from "./events";

package/dist/websocket/index.js

@@ -4,5 +4,6 @@
  * Fundamental definitions for Websocket connections, errors and events.
  */
 export * from "./base";
+export * from "./client";
 export * from "./clients/orderbook-client";
 export * from "./events";

package/dist/wire/schema.d.ts

@@ -1505,8 +1505,16 @@ export interface paths {
          *      Failure semantics: an item that fails validation, or whose original
          *      cannot be found, leaves the original resting. An item whose replacement
          *      fails to PLACE (for example insufficient balance or self-trade
-         *      prevention) reports the error with its original already cancelled — the
-         *      original is never silently left resting after a failed replacement.
+         *      prevention) reports the error with its original already cancelled.
+         *
+         *      POST_ONLY_WOULD_CROSS is the exception: a post-only replacement that
+         *      would cross is refused BEFORE the cancel pass, against the book as it
+         *      will stand once the batch's own cancels are applied, so the item
+         *      normally reports the error with its original still resting. It is not a
+         *      guarantee — the pre-cancel check cannot see what pass 2 will insert or
+         *      consume, nor an original that fails to cancel, and the same original
+         *      listed twice is judged per occurrence — so confirm against open orders
+         *      rather than relying on the code alone.
          */
         post: operations["batch_replace_orders"];
         delete?: never;
@@ -2790,7 +2798,7 @@ export interface components {
              */
             postOnly?: boolean | null;
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Monaco stores and returns this value but does NOT de-duplicate on it and does not enforce uniqueness — it correlates a response to a request, it does not make a retry safe. A create whose response was lost must still be reconciled against ListOrders before resubmitting.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: an item reusing a value another of your resting orders still holds fails that item alone — the batch itself returns 2xx / OK and the offending item's result slot carries error.code CLIENT_ORDER_ID_CONFLICT; no transport-level 409 / ALREADY_EXISTS is raised. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key: resubmitting after a lost response can execute a second time. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and its fan-out is non-persistent Core NATS: the service can re-establish an ended upstream subscription without closing your socket, so events can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. Rejections split in two: an item rejected before acceptance (malformed, post-only would cross, handle conflict, a plain MARKET submit with no liquidity, rejected during pricing) fails only that item — a per-item error in an otherwise-successful response — emits no event and is never written to order history (an item rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent); an accepted LIMIT with IOC or FOK that cannot fill, or an accepted MARKET order whose apparent liquidity is invalidated by maker-risk revalidation, reports matchResult.status REJECTED in its result slot and emits OrderPlaced then OrderRejected, both carrying this value. Neither the batch's 2xx nor a populated result slot therefore means the order executed. Where no surface is conclusive, do not resubmit.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -2869,7 +2877,7 @@ export interface components {
              */
             postOnly?: boolean | null;
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Monaco stores and returns this value but does NOT de-duplicate on it and does not enforce uniqueness — it correlates a response to a request, it does not make a retry safe. A create whose response was lost must still be reconciled against ListOrders before resubmitting. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: an item reusing a value another of your resting orders still holds fails that item alone — the batch itself returns 2xx / OK and the offending item's result slot carries error.code CLIENT_ORDER_ID_CONFLICT; no transport-level 409 / ALREADY_EXISTS is raised. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key, though on this replace path a retry cannot double-execute: the request names the original order id, and the sequencer revalidates that original in memory and on the book at sequence time, so once the first replacement succeeds the original is gone and a retry is rejected with ORDER_NOT_FOUND rather than placing a second order. That code is itself ambiguous — the original may instead have filled or been cancelled — so the risk here is acting on a stale view, not duplicate execution. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and its fan-out is non-persistent Core NATS: the service can re-establish an ended upstream subscription without closing your socket, so events can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. A replace item carries no order type or time-in-force and its original must still be RESTING, so the IOC/FOK and MARKET post-acceptance rejection shapes are unreachable here. Failures split by WHEN they occur, and the difference decides whether your original survives. Before sequencing: a malformed value is caught up front and rejects the whole batch with HTTP 400 / gRPC INVALID_ARGUMENT, and a per-item validation failure fails that item with no mutation and no event. A pre-cancel gate then drops two more classes before anything is cancelled — a handle conflict, and a post-only replacement that would cross the book as it will stand once this batch's originals are cancelled — so in the ordinary POST_ONLY_WOULD_CROSS case the item fails with its original still RESTING and untouched. After that the endpoint is CANCEL-FIRST: the original is cancelled in pass 1, so a residual placement failure then — a self-trade rejection, or a crossing that only became apparent in pass 2 — leaves the original CANCELLED and emits its cancellation events (terminal reason 'replaced') while the item reports the placement error and no replacement is placed. Never assume a failed item left your original resting; read results[] and the stream. Single ReplaceOrder differs: it is atomic, and a rejected replacement leaves the original untouched. Where no surface is conclusive, do not resubmit. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -3296,7 +3304,7 @@ export interface components {
              */
             postOnly?: boolean | null;
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Monaco stores and returns this value but does NOT de-duplicate on it and does not enforce uniqueness — it correlates a response to a request, it does not make a retry safe. A create whose response was lost must still be reconciled against ListOrders before resubmitting.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: a create or replace reusing a value another of your resting orders still holds is rejected with HTTP 409 / gRPC ALREADY_EXISTS and the code CLIENT_ORDER_ID_CONFLICT. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key: resubmitting after a lost response can execute a second time. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and its fan-out is non-persistent Core NATS: the service can re-establish an ended upstream subscription without closing your socket, so events can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. Rejections split in two: one rejected before acceptance (malformed, post-only would cross, handle conflict, a plain MARKET submit with no liquidity, rejected during pricing) fails the request, emits no event and is never written to order history (an order rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent); an accepted LIMIT with IOC or FOK that cannot fill, or an accepted MARKET order whose apparent liquidity is invalidated by maker-risk revalidation, returns 2xx with matchResult.status REJECTED and emits OrderPlaced then OrderRejected, both carrying this value. A 2xx therefore does not mean the order executed. Where no surface is conclusive, do not resubmit.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -3444,6 +3452,28 @@ export interface components {
              * @example oms-3f6a1c
              */
             clientTwapId?: string | null;
+            /**
+             * @description Child execution style. TAKER (default): each slice executes immediately as a banded MARKET order. PASSIVE: each slice rests as a post-only limit at the same-side touch (maker where possible, repriced to follow the touch, never beyond the parent limit price or the protective band), and the leftover is swept as a banded MARKET order at the slice deadline. Passive parents use a slower default slice cadence (~60s).
+             * @example PASSIVE
+             * @enum {string|null}
+             */
+            executionStyle?: "TAKER" | "PASSIVE" | null;
+            /**
+             * @description Price-triggered activation: the parent waits (PENDING) until the reference price reaches or crosses this price in triggerDirection, then runs a floating window of durationSeconds from the trigger instant. Requires triggerDirection and durationSeconds; incompatible with startTime/endTime. Rejected if the condition is already met at creation. Margin markets arm against the oracle mark and the create is rejected while the market has no mark yet (retry once one is published); once the parent is waiting, activation evaluates the mark when it is available and the venue reference price (book-derived median, last-trade fallback) when it is not, so a mark outage cannot leave a live trigger unwatched. Spot markets use the venue reference price throughout.
+             * @example 98000.00
+             */
+            triggerPrice?: string | null;
+            /**
+             * @description Which way the reference price must cross triggerPrice to activate: ABOVE (activate when price rises to or through it) or BELOW (falls to or through it). Required with triggerPrice; no exact print is required — a reference price observed at or beyond the level activates. The condition is evaluated on the engine's own polling cadence rather than on every market tick, so a price that crosses and reverts entirely between two observations is not seen; there is no high/low watermark.
+             * @example BELOW
+             * @enum {string|null}
+             */
+            triggerDirection?: "ABOVE" | "BELOW" | null;
+            /**
+             * @description Deadline for the trigger to fire (RFC 3339, UTC only — Z suffix; non-UTC offsets rejected). If the trigger has not fired by then the parent cancels with terminal reason 'trigger expired'. Only valid with triggerPrice; must be in the future and at most the maximum window (default 30 days) from creation, which is also the default when omitted.
+             * @example 2026-09-01T00:00:00Z
+             */
+            conditionalExpiry?: string | null;
         };
         CreateTwapOrderResponse: {
             /**
@@ -3463,7 +3493,7 @@ export interface components {
              */
             message?: string | null;
             /**
-             * @description Initial parent state: always PENDING at create; the parent activates on its first attempted slice
+             * @description Initial parent state: always PENDING at create. An unconditional parent activates on its first attempted slice; a conditional one (triggerPrice set) stays PENDING until its trigger fires.
              * @example PENDING
              */
             state?: string | null;
@@ -3484,12 +3514,12 @@ export interface components {
              */
             plannedSlices?: number | null;
             /**
-             * @description Planned time of the first slice (ISO 8601)
+             * @description Planned time of the first slice (ISO 8601). PROVISIONAL for a conditional parent (triggerPrice set): its window floats from the trigger instant, which is unknown at create, so this is computed from the provisional [create, create + durationSeconds] window and is re-anchored when the trigger fires. Read the armed window back from the TWAP read model (startAt / endAt / triggeredAt) instead of scheduling on this value.
              * @example 2026-08-01T10:00:27Z
              */
             firstSliceAt?: string | null;
             /**
-             * @description Resolved window end (ISO 8601). Execution never continues past it.
+             * @description Resolved window end (ISO 8601). Execution never continues past it. PROVISIONAL for a conditional parent (triggerPrice set) for the same reason as firstSliceAt: the real window is [trigger instant, trigger instant + durationSeconds] and is re-anchored on activation.
              * @example 2026-08-01T11:00:00Z
              */
             endTime?: string | null;
@@ -4034,6 +4064,14 @@ export interface components {
             riskBucketId?: string | null;
             marginMode?: string | null;
             selectedTradingPairIds?: string[] | null;
+            /**
+             * @description See `MarginAccountSummary.available_order_collateral`: the collateral
+             *      still available to open NEW orders in this risk bucket, the risk engine
+             *      admission gate's own bound with parent auto top-up included. Present only
+             *      on risk-bucket rows served from a live engine snapshot; absent on parent
+             *      rows and persisted-fallback reads.
+             */
+            availableOrderCollateral?: string | null;
         };
         GetMarkPriceResponse: {
             /** Format: uuid */
@@ -4399,7 +4437,7 @@ export interface components {
              */
             remainingQuantityRaw?: string | null;
             /**
-             * @description Client-assigned correlation handle as stored: the value supplied on create or replace, with surrounding whitespace trimmed. Absent when the order carried none, including every order placed before the field was accepted on write. Not unique: Monaco neither de-duplicates nor enforces uniqueness, so several orders may share one value and a lookup by it can be ambiguous.
+             * @description Client-assigned correlation handle as stored: the value supplied on create or replace, with surrounding whitespace trimmed. Absent when the order carried none, including every order placed before the field was accepted on write. Uniqueness is enforced only among your orders that are RESTING on the book, so several of your orders may share one value over time and a lookup by it can be ambiguous: an order that never rests never takes the handle, and the value is released the moment any order reaches a terminal state. It is a correlation handle, not an idempotency key.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -5676,6 +5714,42 @@ export interface components {
             marginMode?: string | null;
             /** @description Present for cross risk-bucket summary rows. */
             selectedTradingPairIds?: string[] | null;
+            /**
+             * @description The collateral still available to open NEW orders in this risk bucket:
+             *      the largest increase in the bucket's worst-case order reserve the risk
+             *      engine's admission gate accepts, automatic top-up from the parent margin
+             *      account's unallocated capacity included. Zero while the account or bucket
+             *      is frozen for liquidation, and for an isolated bucket whose market is
+             *      halted. (A cross bucket's market is chosen per order, so a halt cannot be
+             *      folded into its figure — a halted pair still refuses orders.)
+             *
+             *      The trading-side sibling of `withdrawable_collateral`, and deliberately a
+             *      different figure: this one credits an unrealized gain in full, because a
+             *      gain is legitimate initial margin for new positions, while a withdrawal
+             *      never counts one. It already contains the bucket's live free collateral —
+             *      do not add `free_collateral` or `unrealized_pnl` on top. It can also
+             *      legitimately differ from this row's `free_collateral`, which is a
+             *      persisted reconstruction that cannot see the engine's worst-case
+             *      resting-order reserve.
+             *
+             *      NOT additive across rows: every bucket's figure includes the SAME parent
+             *      unallocated headroom, so summing rows multiply-counts it, and committing
+             *      collateral in one bucket shrinks its siblings' figures.
+             *
+             *      This is a requirement budget, not an order size: an order is charged the
+             *      increase it causes in the bucket's worst-case per-pair reserve, so a
+             *      reducing, reduce-only, or opposite-side order sheltered by a larger
+             *      resting ladder needs less or none of it (and can be admitted even when
+             *      this field is zero), while an order crossing a losing position can need
+             *      more than its own margin-plus-fee. Divide by a market's initial margin
+             *      rate for indicative notional capacity; the authoritative per-order answer
+             *      remains `simulate_risk_bucket_order_risk`.
+             *
+             *      Present only on risk-bucket summary rows served from a live risk engine
+             *      snapshot; absent on parent rows and on persisted-fallback reads, where
+             *      neither of the gate's terms is reconstructable.
+             */
+            availableOrderCollateral?: string | null;
         };
         MatchResult: {
             /**
@@ -6051,6 +6125,19 @@ export interface components {
              *      may carry sub-tick tails).
              */
             withdrawableCollateral?: string | null;
+            /**
+             * @description The collateral still available to open NEW orders in this risk bucket —
+             *      the same engine-served admission bound as
+             *      `MarginAccountSummary.available_order_collateral` (see that field for the
+             *      full semantics: an envelope delta with parent auto top-up included, NOT
+             *      additive across rows, zero while frozen), truncated toward zero at quote
+             *      decimals like `withdrawable_collateral` beside it.
+             *
+             *      Present only when a live risk engine snapshot served the bound; absent on
+             *      persisted-fallback reads, where neither of the gate's terms is
+             *      reconstructable.
+             */
+            availableOrderCollateral?: string | null;
         };
         PortfolioSeriesWindow: {
             /**
@@ -6455,7 +6542,7 @@ export interface components {
         };
         ReplaceOrderRequest: {
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Monaco stores and returns this value but does NOT de-duplicate on it and does not enforce uniqueness — it correlates a response to a request, it does not make a retry safe. A create whose response was lost must still be reconciled against ListOrders before resubmitting. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: a create or replace reusing a value another of your resting orders still holds is rejected with HTTP 409 / gRPC ALREADY_EXISTS and the code CLIENT_ORDER_ID_CONFLICT. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key, though on this replace path a retry cannot double-execute: the request names the original order id, and the sequencer revalidates that original in memory and on the book at sequence time, so once the first replacement succeeds the original is gone and a retry is rejected with ORDER_NOT_FOUND rather than placing a second order. That code is itself ambiguous — the original may instead have filled or been cancelled — so the risk here is acting on a stale view, not duplicate execution. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and its fan-out is non-persistent Core NATS: the service can re-establish an ended upstream subscription without closing your socket, so events can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. A replacement carries no order type or time-in-force and its original must still be RESTING, so the post-acceptance rejection shapes are unreachable here: the reachable failures are all pre-acceptance — malformed, post-only would cross, handle conflict, or the original no longer resting (ORDER_NOT_FOUND) — and each fails the request, emits no event and is never written to order history (an order rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent). Where no surface is conclusive, do not resubmit. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -7460,6 +7547,19 @@ export interface components {
             cancelledAt?: string | null;
             /** @description Completion timestamp (ISO 8601) */
             completedAt?: string | null;
+            /**
+             * @description Child execution style: TAKER (banded MARKET slices) or PASSIVE (post-only children at the touch with a taker sweep at each slice deadline)
+             * @example TAKER
+             */
+            executionStyle?: string | null;
+            /** @description Price-triggered activation level, when this parent is conditional */
+            triggerPrice?: string | null;
+            /** @description Trigger crossing direction: ABOVE or BELOW */
+            triggerDirection?: string | null;
+            /** @description Deadline for the trigger to fire (ISO 8601 UTC); reaching it cancels the parent with terminal reason 'trigger expired' */
+            conditionalExpiry?: string | null;
+            /** @description When the trigger fired and the floating window started (ISO 8601 UTC); unset while waiting */
+            triggeredAt?: string | null;
         };
         UpdateLimitRequest: {
             /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "1.0.46",
+	"version": "1.0.48",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -16,7 +16,7 @@
 		"lint": "biome lint ."
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.46",
+		"@0xmonaco/contracts": "1.0.48",
 		"zod": "^4.1.12"
 	},
 	"peerDependencies": {