@0xmonaco/types 1.0.50 → 1.0.53

package/dist/websocket/client.js

@@ -7,4 +7,43 @@
  * 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.
+ *
+ * ## Subscribe-time snapshots
+ *
+ * Every subscription whose channel has a server-side baseline takes an
+ * optional trailing `onSnapshot`. It receives that channel's COMPLETE current
+ * state as one array, once, before the first live event — so a consumer can
+ * seed state from the socket instead of a REST read, and replace it wholesale
+ * after a reconnect.
+ *
+ * The argument is deliberately trailing and optional on every method: adding a
+ * required parameter, or inserting one ahead of an existing optional filter,
+ * would break every existing call site.
+ *
+ * Snapshot rows go to `onSnapshot` and nowhere else. They are the channel's
+ * terminal-state payload rather than its event envelope (see
+ * {@link SnapshotHandler}), so a consumer that reduced them through the event
+ * handler too would apply the same baseline twice.
+ *
+ * Snapshot frames are routed by the FULL canonical channel string, unlike live
+ * events, which are prefix-matched. That is what keeps two pair-scoped
+ * subscriptions' baselines on their own callbacks.
+ *
+ * **One baseline per wire subscription, not per call.** The client sends one
+ * `Subscribe` for a channel however many local handlers it has, and the server
+ * snapshots only genuinely new subscriptions — so on a channel this client
+ * already holds, a second subscriber's `onSnapshot` is not invoked until the
+ * next reconnect resubscribes. `instruments` is the exception: it caches its
+ * baseline locally and replays it to a late subscriber. The other channels
+ * cannot reuse that cache — `orders` snapshot rows are not the shape its live
+ * events carry, so there is nothing to keep the cache current with — and a
+ * stale replayed baseline would be worse than none. Subscribe once per channel
+ * and fan out in application code (a React hook already does this), or read the
+ * baseline over REST for the extra consumer.
+ *
+ * Where the server has no snapshot arm for a channel yet, the callback is
+ * simply never invoked — a silent no-op, not an error. `orderbook`, `ohlcv`,
+ * `trades` and `movements` take no `onSnapshot` at all: they stream events
+ * rather than state, and the channel-coverage lock pins that classification
+ * against the server's own snapshot dispatch.
  */

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

@@ -45,7 +45,7 @@ export interface UserBalanceEventData {
     /** Total balance in raw format (wei) */
     totalRaw: string;
     /** Reason for the balance update */
-    reason: BalanceUpdateReason;
+    reason: BalanceUpdateReason | (string & {});
     /** Reference ID for related entity (e.g., order ID, deposit ID) */
     referenceId: string | null;
     /** Timestamp when the balance was updated (ISO 8601) */

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

@@ -13,7 +13,10 @@ export type ConditionalOrderEventReason = "created" | "activated" | "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
+ * runtime guarantee** — which is why each of those fields is typed
+ * `Union | (string & {})`: autocomplete still offers the known values, but a
+ * `switch` over one needs a `default` branch because an unrecognized value
+ * really can arrive (0XM-2628). `@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
@@ -36,13 +39,13 @@ export interface ConditionalOrderEventData {
     marginAccountId: string;
     positionId?: string;
     parentOrderId?: string;
-    associationType?: "POSITION" | "PARENT_ORDER";
+    associationType?: "POSITION" | "PARENT_ORDER" | (string & {});
     linkedGroupId?: string;
-    conditionType: ConditionalOrderConditionType;
-    triggerSource: ConditionalOrderTriggerSource;
+    conditionType: ConditionalOrderConditionType | (string & {});
+    triggerSource: ConditionalOrderTriggerSource | (string & {});
     triggerPrice: string;
-    side: OrderSide;
-    positionSide: PositionSide;
+    side: OrderSide | (string & {});
+    positionSide: PositionSide | (string & {});
     /**
      * Order shape the conditional order places when it triggers.
      *
@@ -58,7 +61,7 @@ export interface ConditionalOrderEventData {
      * the value would arrive as e.g. `STOPLOSS` rather than the canonical
      * `STOP_LOSS`. The parser passes such a value through untouched.
      */
-    orderType: OrderType;
+    orderType: OrderType | (string & {});
     limitPrice?: string;
     quantity?: string;
     slippageToleranceBps?: number;
@@ -71,8 +74,8 @@ export interface ConditionalOrderEventData {
      * 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;
+    timeInForce?: TimeInForce | (string & {});
+    state: ConditionalOrderState | (string & {});
     triggeredOrderId?: string;
     triggeredAt?: string;
     activatedAt?: string;
@@ -87,6 +90,28 @@ export interface ConditionalOrderEventData {
      */
     reason: string;
     updatedAt: string;
+    /**
+     * Opaque, compare-only revision counter for this conditional order's state —
+     * the sequencer step that wrote it (0XM-2440). A strictly higher value is
+     * strictly newer state for that conditional order.
+     *
+     * Present on REST reads and on the subscribe-time `conditional_orders`
+     * snapshot frame. **Absent on live conditional events**, by design: those are
+     * emitted from a model captured before the sequencer acted, so the only value
+     * available there is the one the row held *before* the change being
+     * announced — a client merging on `>=` would let a snapshot read at that
+     * version win the tie and undo the transition.
+     *
+     * So seed conditional state from the snapshot and REST, comparing with
+     * `snapshot.version >= local.version`, and apply live events as state without
+     * ranking them. `>=` rather than `>`: one sequencer step can write several
+     * conditional rows (a trigger writes the triggered row and cancels its OCO
+     * sibling), so equal means "same step", not identical state.
+     *
+     * Absent means unknown — a row last written before the field existed — never
+     * zero. Wire: `version`.
+     */
+    version?: number;
 }
 export interface ConditionalOrderEvent {
     eventType: "conditional_order_update";

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

@@ -36,8 +36,18 @@ export type InstrumentChangeKind = "listing" | "delisting" | "halt" | "unhalt" |
  * Full current configuration for a market on the `instrument` channel.
  */
 export interface InstrumentEventData {
-    /** What changed for this market */
-    change: InstrumentChangeKind;
+    /**
+     * What changed for this market.
+     *
+     * Widened past {@link InstrumentChangeKind} on purpose: `@0xmonaco/core`
+     * parses this frame leniently, so a change kind added server-side after this
+     * SDK version ships is delivered as-is rather than dropping the frame — and
+     * with it the full market config the frame carries, which can hide a market
+     * going inactive behind an unfamiliar label (0XM-2628).
+     * `InstrumentChangeKind` names the values the server sends today — narrow
+     * with a `switch` that keeps a `default` branch.
+     */
+    change: InstrumentChangeKind | (string & {});
     /** Trading pair identifier (UUID) */
     tradingPairId: string;
     /** Market symbol, e.g. "BTC/USDC" */

package/dist/websocket/events/market-stats-events.d.ts

@@ -85,6 +85,11 @@ export interface MarketStatsEvent {
 /**
  * A single market's row in the all-markets summary frame. A lighter shape than
  * {@link MarketStatsData}: enough to render a markets table.
+ *
+ * `marketStatus` is typed `MarketStatus | (string & {})`: `@0xmonaco/core`
+ * parses this frame leniently, so an unrecognized status is passed through
+ * rather than throwing and dropping the summary row (0XM-2628). `MarketStatus`
+ * names the values the server sends today — match it with a `default` branch.
  */
 export interface MarketStatsSummary {
     /** Trading pair identifier (UUID) */
@@ -114,7 +119,7 @@ export interface MarketStatsSummary {
     /** Next funding time as a millisecond epoch. Perp-only; omitted for spot. */
     fundingTimestamp?: number;
     /** Tradability label (always present) */
-    marketStatus: MarketStatus;
+    marketStatus: MarketStatus | (string & {});
 }
 /**
  * All-markets summary event on the `market_stats` channel: one

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

@@ -21,15 +21,20 @@ export interface OHLCVEvent {
     /** Trading pair ID (UUID) */
     tradingPairId: string;
     /** Candlestick interval */
-    interval: Interval;
+    interval: Interval | (string & {});
     /** Trading mode */
-    tradingMode: TradingMode;
+    tradingMode: TradingMode | (string & {});
     /**
      * Price series this candle belongs to. Always a concrete series on the wire
      * (`trade` or `mark`, never the `*` selector); lets a wildcard subscriber
      * tell the two streams apart. Absent only on legacy frames that omit it.
+     *
+     * Widened past the two known values on purpose: a wildcard subscription
+     * matches any suffix, so a series added server-side after this version still
+     * arrives here, and telling the streams apart is the entire point of the
+     * field. Match it with a `default` branch.
      */
-    priceType?: "trade" | "mark";
+    priceType?: "trade" | "mark" | (string & {});
     /** OHLCV candlestick data */
     candlestick: Candlestick;
 }

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

@@ -29,7 +29,7 @@ export interface OrderbookLevel {
  */
 export interface PriceChange {
     /** Order side (BUY or SELL) */
-    side: OrderSide;
+    side: OrderSide | (string & {});
     /** Old price before the change */
     oldPrice?: string;
     /** New price after the change */
@@ -46,7 +46,7 @@ export interface OrderbookEvent {
     /** Trading pair ID (UUID) */
     tradingPairId: string;
     /** Trading mode (SPOT, MARGIN) */
-    tradingMode: TradingMode;
+    tradingMode: TradingMode | (string & {});
     /** Bid orders (buy orders) - Full depth */
     bids: OrderbookLevel[];
     /** Ask orders (sell orders) - Full depth */

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

@@ -18,7 +18,7 @@ export interface OrderEvent {
     /** Order ID (UUID) */
     orderId: string;
     /** Event type */
-    eventType: OrderEventType;
+    eventType: OrderEventType | (string & {});
     /** ISO 8601 timestamp */
     timestamp: string;
     /** Event-specific data */
@@ -46,11 +46,11 @@ export interface CommonOrderEventData {
      */
     tradingPair: string;
     /** Trading mode (e.g., "SPOT", "MARGIN") */
-    tradingMode: TradingMode;
+    tradingMode: TradingMode | (string & {});
     /** Order type - present in most events */
-    orderType?: OrderType;
+    orderType?: OrderType | (string & {});
     /** Order side - present in most events */
-    side?: OrderSide;
+    side?: OrderSide | (string & {});
     /** Order price - present in most events */
     price?: string;
     /** Order quantity - present in most events */
@@ -58,7 +58,7 @@ export interface CommonOrderEventData {
     /** Order quantity in RAW (integer, base-unit) precision. Wire: `quantity_raw`. */
     quantityRaw?: string;
     /** Time in force - present in most events */
-    timeInForce?: TimeInForce;
+    timeInForce?: TimeInForce | (string & {});
     /**
      * Client-assigned correlation handle, echoed so an event can be matched to
      * the request that placed the order without a round trip to `getOrder`.
@@ -79,6 +79,65 @@ export interface CommonOrderEventData {
      * silence. Omitted when the order carried none. Wire: `client_order_id`.
      */
     clientOrderId?: string;
+    /**
+     * Sequencer step that produced this event (0XM-2440) — the SAME counter
+     * `getOrder` and `getPaginatedOrders` return, so the two are directly
+     * comparable. Higher is strictly newer for that order.
+     *
+     * This is what makes a reconnect reconcilable without buffering: apply
+     * events as they arrive, and when the REST snapshot lands take the snapshot
+     * for an order when `snapshot.version >= local.version`, else keep local.
+     *
+     * **Equal does NOT mean identical state here.** One sequencer step emits
+     * several events for one order (an `OrderPlaced` and then its fills), and a
+     * batch place/replace shares one step across every item — so equal means
+     * "same step". A snapshot row is that step's FINAL state, which is why the
+     * rule is `>=` and not `>`: on a tie the snapshot is the authority.
+     *
+     * Values are sparse per order (it comes from a global sequence) and are not
+     * comparable between different orders. Omitted, never zero, when unknown —
+     * an order last written before the field existed. Wire: `version`.
+     */
+    version?: number;
+    /**
+     * `true` when the order was admitted post-only (maker-only), so a subscriber
+     * can confirm the flag was honoured without a round trip to `getOrder`.
+     * Carried on the `OrderPlaced` acknowledgement, the taker fill, and the
+     * resting order's lifecycle — `OrderPartiallyCancelled` (an in-place
+     * reduction, which is how an MM's own `remainingQuantityTarget` replace is
+     * announced), `OrderCancelled` and `OrderExpired`.
+     *
+     * Declared on the shared block, but two variants can never carry it, and
+     * this optional field is the only thing that says so: a **maker fill**,
+     * which is out of scope because a maker already learned the flag from its
+     * own acknowledgement; and **`OrderRejected`**, which only ever describes a
+     * MARKET order with no liquidity or an unfilled IOC/FOK — and post-only is
+     * refused on both, so no post-only order can reach it.
+     *
+     * Only ever present as `true`: on a variant that CARRIES the field, an order
+     * that is not post-only omits the key rather than sending `postOnly: false`,
+     * exactly as the REST read model's `postOnly?: boolean` does, so
+     * `event.data.postOnly ?? false` reads the same as REST *for that event*.
+     *
+     * That equivalence is per-event, and it does NOT hold on a maker fill.
+     * A post-only order rests and therefore fills as a maker, and the maker
+     * payload never declares the field — so `?? false` there would return
+     * `false` for an order REST reports as `true`. Absence on a maker fill
+     * carries NO information. Track `postOnly` as order-level state learned from
+     * the `OrderPlaced` acknowledgement (or a REST read) and carry it forward;
+     * never re-derive it from whichever event arrived last.
+     *
+     * On a carrying variant, absent is not evidence the flag was dropped — it is
+     * the ordinary shape of a non-post-only order, and also what an order placed
+     * before the flag was persisted reports.
+     *
+     * A post-only order that WOULD have crossed the book is rejected before
+     * acceptance and emits no event at all (see `clientOrderId`), so in practice
+     * the flag reaches a subscriber on a resting order's lifecycle — never on a
+     * taker fill, which an admitted post-only order cannot produce.
+     * Wire: `post_only`.
+     */
+    postOnly?: boolean;
 }
 /**
  * OrderPlaced event - emitted when a new order is placed
@@ -87,54 +146,94 @@ export interface OrderPlacedEvent extends OrderEvent {
     eventType: "OrderPlaced";
     data: CommonOrderEventData & {
         /** Order status */
-        status: OrderStatus;
+        status: OrderStatus | (string & {});
     };
 }
 /**
  * OrderMatched event - emitted when an order is matched but not necessarily filled
- * This event is only emitted for taker orders
+ * This event is only emitted for taker orders.
+ *
+ * Carries the SAME payload as `OrderFilled`/`OrderPartiallyFilled`: the
+ * matching engine builds one `TakerOrderEventData` and picks the event type
+ * from the resulting status, so every execution field below is on the wire
+ * here too.
+ *
+ * Because this event carries only that one shape, the fields below follow it
+ * exactly rather than being uniformly optional. A match that filled nothing
+ * still SENDS the keys — `tradeId`, `executionPrice` and `executedAt` arrive as
+ * `null`, not absent. Only `lastFillQuantity` and `lastFillQuantityRaw` are
+ * ever omitted, being the pair the server skips when there is no incremental
+ * fill.
  */
 export interface OrderMatchedEvent extends OrderEvent {
     eventType: "OrderMatched";
     data: CommonOrderEventData & {
-        /** Taker order ID */
-        takerOrderId?: string;
-        /** Reference price used for slippage calculation */
-        referencePrice?: string;
-        /** Best price achieved in matching */
-        bestPrice?: string;
-        /** Worst price achieved in matching */
-        worstPrice?: string;
-        /** Actual slippage in basis points */
-        actualSlippageBps?: number;
-        /** Maximum allowed slippage in basis points */
-        maxSlippageBps?: number;
-        /** Number of trades executed (taker only) */
-        tradesCount?: number;
-        /** Total quantity filled (taker only) */
-        totalFilled?: string;
-        /** Remaining quantity to be filled (taker only) */
-        remainingQuantity?: string;
-        /** Average fill price across all trades */
-        averageFillPrice?: string;
-        /** Order status */
-        status?: OrderStatus;
+        /** Fill role of this order (`taker` on this event). */
+        role: OrderRole | (string & {});
+        /** Trade ID of the first trade this event covers. `null` when it covers none. */
+        tradeId: string | null;
+        /** Execution price of the first trade this event covers. `null` when it covers none. */
+        executionPrice: string | null;
+        /** Cumulative quantity filled on the order at this event. Wire: `filled_quantity`. */
+        filledQuantity: string;
+        /** `filledQuantity` in RAW (integer, base-unit) precision. Wire: `filled_quantity_raw`. */
+        filledQuantityRaw: string;
+        /** Incremental quantity filled by THIS event. Omitted when there is no fill. Wire: `last_fill_quantity`. */
+        lastFillQuantity?: string;
+        /** `lastFillQuantity` in RAW (integer, base-unit) precision. Omitted with it. Wire: `last_fill_quantity_raw`. */
+        lastFillQuantityRaw?: string;
+        /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
+        remainingQuantityRaw: string;
+        /**
+         * Monaco fee for the fills this event covers, in normalized decimal QUOTE
+         * units (negative = maker rebate). Excludes the application taker fee, so
+         * it is smaller than the order echo's `totalTakerFees` for an application
+         * that charges one, and equal to it for one that does not. Wire: `fee`.
+         */
+        fee: string;
+        /**
+         * `fee` in RAW quote-unit precision (scaled by 10^quoteDecimals). Always a
+         * whole number -- the engine truncates every fee to an integral raw unit
+         * when it stores it -- so `fee` is exactly this value divided by
+         * 10^quoteDecimals, and `BigInt(feeRaw)` is safe. Wire: `fee_raw`.
+         */
+        feeRaw: string;
+        /** Execution timestamp of the first trade this event covers (ISO 8601). `null` when it covers none. */
+        executedAt: string | null;
+        /** Reference price used for slippage calculation. `null` when unset. */
+        referencePrice: string | null;
+        /** Best price achieved in matching. `null` when unset. */
+        bestPrice: string | null;
+        /** Worst price achieved in matching. `null` when unset. */
+        worstPrice: string | null;
+        /** Actual slippage in basis points. `null` when unset. */
+        actualSlippageBps: number | null;
+        /** Maximum allowed slippage in basis points. `null` when unset. */
+        maxSlippageBps: number | null;
+        /** Number of trades executed. */
+        tradesCount: number;
+        /** Remaining quantity to be filled. */
+        remainingQuantity: string;
+        /** Average fill price across all trades. `null` when there is none. */
+        averageFillPrice: string | null;
+        /** Order status. */
+        status: OrderStatus | (string & {});
     };
 }
 /**
  * OrderPartiallyFilled event - emitted when an order is partially filled
- * Can be emitted for both taker and maker orders with different field sets
+ * Can be emitted for both taker and maker orders with different field sets.
  *
- * Taker events include: trades_count, total_filled, slippage data
- * Maker events include: trade_id, execution_price, execution_quantity, maker_fee
+ * Taker events add `trades_count` and the slippage fields; maker events add
+ * `trade_id` and `execution_price`. Both roles report the cumulative fill as
+ * `filled_quantity` and this event's increment as `last_fill_quantity`, and
+ * both carry the fill charge as `fee` (0XM-2389). `total_filled`,
+ * `execution_quantity` and `maker_fee` were never emitted on a fill payload
+ * and are not declared here.
  */
 export interface OrderPartiallyFilledEvent extends OrderEvent {
     eventType: "OrderPartiallyFilled";
     data: CommonOrderEventData & {
-        /** Taker order ID (taker orders only) */
-        takerOrderId?: string;
-        /** Maker order ID (maker orders only) */
-        makerOrderId?: string;
         /** Reference price (taker orders only) */
         referencePrice?: string;
         /** Best price (taker orders only) */
@@ -147,14 +246,12 @@ export interface OrderPartiallyFilledEvent extends OrderEvent {
         maxSlippageBps?: number;
         /** Number of trades (taker orders only - not present for maker) */
         tradesCount?: number;
-        /** Total filled quantity (taker orders only - not present for maker) */
-        totalFilled?: string;
         /** Remaining quantity (present for both taker and maker) */
         remainingQuantity?: string;
         /** Average fill price (taker orders only) */
         averageFillPrice?: string;
         /** Order status (taker orders only) */
-        status?: OrderStatus;
+        status?: OrderStatus | (string & {});
         /** Trade ID (maker orders only) */
         tradeId?: string;
         /** Execution price (maker orders only) */
@@ -180,30 +277,43 @@ export interface OrderPartiallyFilledEvent extends OrderEvent {
         /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
         remainingQuantityRaw?: string;
         /**
-         * Fee charged for this fill (maker orders only). The wire field is `fee`
-         * (→ `fee`), not `makerFee`; taker fills carry the same `fee` field.
+         * Monaco fee for the fills this event covers, in normalized decimal QUOTE
+         * units (negative = maker rebate). The wire field is `fee`, not `makerFee`;
+         * taker and maker carry the same field. A taker event aggregates every
+         * trade it covers; a maker event is one trade.
+         *
+         * Excludes the application taker fee, so it is NOT the order echo's
+         * `totalTakerFees` (which is `fee + applicationTakerFee`). It previously
+         * held the raw integer value now exposed as `feeRaw`.
          */
         fee?: string;
+        /**
+         * `fee` in RAW quote-unit precision (scaled by 10^quoteDecimals). Always a
+         * whole number -- the engine truncates every fee to an integral raw unit
+         * when it stores it -- so `fee` is exactly this value divided by
+         * 10^quoteDecimals, and `BigInt(feeRaw)` is safe. Wire: `fee_raw`.
+         */
+        feeRaw?: string;
         /** Trade execution timestamp (maker orders only) */
         executedAt?: string;
         /** Role of the order in the trade (taker or maker) */
-        role?: OrderRole;
+        role?: OrderRole | (string & {});
     };
 }
 /**
  * OrderFilled event - emitted when an order is completely filled
- * Can be emitted for both taker and maker orders with different field sets
+ * Can be emitted for both taker and maker orders with different field sets.
  *
- * Taker events include: trades_count, total_filled, slippage data
- * Maker events include: trade_id, execution_price, execution_quantity, maker_fee
+ * Taker events add `trades_count` and the slippage fields; maker events add
+ * `trade_id` and `execution_price`. Both roles report the cumulative fill as
+ * `filled_quantity` and this event's increment as `last_fill_quantity`, and
+ * both carry the fill charge as `fee` (0XM-2389). `total_filled`,
+ * `execution_quantity` and `maker_fee` were never emitted on a fill payload
+ * and are not declared here.
  */
 export interface OrderFilledEvent extends OrderEvent {
     eventType: "OrderFilled";
     data: CommonOrderEventData & {
-        /** Taker order ID (taker orders only) */
-        takerOrderId?: string;
-        /** Maker order ID (maker orders only) */
-        makerOrderId?: string;
         /** Reference price (taker orders only) */
         referencePrice?: string;
         /** Best price (taker orders only) */
@@ -216,14 +326,12 @@ export interface OrderFilledEvent extends OrderEvent {
         maxSlippageBps?: number;
         /** Number of trades (taker orders only - not present for maker) */
         tradesCount?: number;
-        /** Total filled quantity (taker orders only - not present for maker) */
-        totalFilled?: string;
         /** Remaining quantity (present for both, should be 0 for filled orders) */
         remainingQuantity?: string;
         /** Average fill price (taker orders only) */
         averageFillPrice?: string;
         /** Order status (taker orders only) */
-        status?: OrderStatus;
+        status?: OrderStatus | (string & {});
         /** Trade ID (maker orders only) */
         tradeId?: string;
         /** Execution price (maker orders only) */
@@ -249,14 +357,27 @@ export interface OrderFilledEvent extends OrderEvent {
         /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
         remainingQuantityRaw?: string;
         /**
-         * Fee charged for this fill (maker orders only). The wire field is `fee`
-         * (→ `fee`), not `makerFee`; taker fills carry the same `fee` field.
+         * Monaco fee for the fills this event covers, in normalized decimal QUOTE
+         * units (negative = maker rebate). The wire field is `fee`, not `makerFee`;
+         * taker and maker carry the same field. A taker event aggregates every
+         * trade it covers; a maker event is one trade.
+         *
+         * Excludes the application taker fee, so it is NOT the order echo's
+         * `totalTakerFees` (which is `fee + applicationTakerFee`). It previously
+         * held the raw integer value now exposed as `feeRaw`.
          */
         fee?: string;
+        /**
+         * `fee` in RAW quote-unit precision (scaled by 10^quoteDecimals). Always a
+         * whole number -- the engine truncates every fee to an integral raw unit
+         * when it stores it -- so `fee` is exactly this value divided by
+         * 10^quoteDecimals, and `BigInt(feeRaw)` is safe. Wire: `fee_raw`.
+         */
+        feeRaw?: string;
         /** Trade execution timestamp (maker orders only) */
         executedAt?: string;
         /** Role of the order in the trade (taker or maker) */
-        role?: OrderRole;
+        role?: OrderRole | (string & {});
     };
 }
 /**
@@ -268,7 +389,7 @@ export interface OrderCancelledEvent extends OrderEvent {
         /** Reason for cancellation */
         reason?: string;
         /** Stable machine-readable cancellation cause */
-        terminalReason?: OrderTerminalReason;
+        terminalReason?: OrderTerminalReason | (string & {});
         /**
          * Cumulative order fill at cancellation, mirroring `filledQuantity` on the
          * taker/maker fill events so consumers read one field across every order
@@ -308,11 +429,15 @@ export interface OrderRejectedEvent extends OrderEvent {
         /** Reason for rejection */
         reason: string;
         /** Order status */
-        status: OrderStatus;
+        status: OrderStatus | (string & {});
         /** Total filled quantity (may-be partially filled) */
         totalFilled: string;
+        /** `totalFilled` in RAW (integer, base-unit) precision. Wire: `total_filled_raw`. */
+        totalFilledRaw: string;
         /** Remaining quantity that couldn't be filled */
         remainingQuantity: string;
+        /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
+        remainingQuantityRaw: string;
     };
 }
 /**
@@ -321,12 +446,16 @@ export interface OrderRejectedEvent extends OrderEvent {
 export interface OrderExpiredEvent extends OrderEvent {
     eventType: "OrderExpired";
     data: CommonOrderEventData & {
-        /** Filled quantity before expiration */
-        filledQuantity?: string;
-        /** Remaining quantity at expiration */
-        remainingQuantity?: string;
-        /** Average fill price (if any fills occurred) */
-        averageFillPrice?: string;
+        /** Filled quantity before expiration. `null` when the order never filled. */
+        filledQuantity: string | null;
+        /** `filledQuantity` in RAW (integer, base-unit) precision. Wire: `filled_quantity_raw`. */
+        filledQuantityRaw: string | null;
+        /** Remaining quantity at expiration. `null` when unset. */
+        remainingQuantity: string | null;
+        /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
+        remainingQuantityRaw: string | null;
+        /** Average fill price. `null` when no fills occurred. */
+        averageFillPrice: string | null;
         /** Reason for expiration */
         reason: string;
     };
@@ -342,7 +471,7 @@ export interface OrderPartiallyCancelledEvent extends OrderEvent {
     eventType: "OrderPartiallyCancelled";
     data: CommonOrderEventData & {
         /** Order status — non-terminal (the order still rests) */
-        status: OrderStatus;
+        status: OrderStatus | (string & {});
         /** Cumulative filled quantity, unchanged by the reduction */
         filledQuantity: string;
         /** Cumulative filled quantity in RAW precision. Wire: `filled_quantity_raw`. */

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

@@ -23,6 +23,12 @@ export type PositionEventSide = "LONG" | "SHORT";
 export type PositionEventStatus = "OPEN" | "LIQUIDATING" | "CLOSED" | "LIQUIDATED" | "EXPIRED";
 /**
  * Position event data containing the current state of a single position.
+ *
+ * `side` and `status` are typed `Union | (string & {})`: `@0xmonaco/core`
+ * parses this frame leniently, so an unrecognized value is passed through
+ * rather than throwing inside the WebSocket message handler and dropping a
+ * risk-critical update entirely (0XM-2627/0XM-2628). The unions name the values
+ * the server sends today — `switch` over them with a `default` branch.
  */
 export interface PositionEventData {
     /** Position identifier (UUID) */
@@ -32,9 +38,9 @@ export interface PositionEventData {
     /** Trading pair identifier (UUID) */
     tradingPairId: string;
     /** Position side */
-    side: PositionEventSide;
+    side: PositionEventSide | (string & {});
     /** Position lifecycle status (SCREAMING_SNAKE_CASE on the wire, e.g. "OPEN") */
-    status: PositionEventStatus;
+    status: PositionEventStatus | (string & {});
     /** Absolute position size (decimal string) */
     size: string;
     /** Average entry price (decimal string) */