@0xmonaco/types 1.0.47 → 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/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/wire/schema.d.ts

@@ -4064,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 */
@@ -5706,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: {
             /**
@@ -6081,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: {
             /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "1.0.47",
+	"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.47",
+		"@0xmonaco/contracts": "1.0.48",
 		"zod": "^4.1.12"
 	},
 	"peerDependencies": {