@0xmonaco/types 1.0.65 → 1.0.67

package/dist/websocket/base.d.ts

@@ -64,9 +64,11 @@ export type WebSocketErrorCode =
  */
  | "SNAPSHOT_UNAVAILABLE"
 /**
- * The per-connection inbound message-rate cap was exceeded; the connection
- * is closed (1008) after this frame. Batch subscriptions and back off
- * before reconnecting — a hot re-subscribe loop trips the cap again.
+ * A per-connection inbound cap was exceeded: the message rate, or the byte
+ * budget that refuses a burst of very large frames. The connection is
+ * closed (1008) after this frame. Batch subscriptions, keep frames small,
+ * and back off before reconnecting — a hot re-subscribe loop trips the cap
+ * again.
  */
  | "MESSAGE_RATE_LIMIT";
 /**
@@ -82,9 +84,39 @@ export interface WebSocketErrorInfo {
     code: WebSocketErrorCode | (string & {});
     /** Human-readable description; for logging and display, never for branching. */
     message: string;
+    /**
+     * The channel a per-channel failure concerns, echoed exactly as this client
+     * sent it (an unparseable string included). Present on
+     * `INVALID_SUBSCRIPTION`, `AUTH_REQUIRED`, `SUBSCRIPTION_LIMIT` and
+     * `SNAPSHOT_UNAVAILABLE`; absent on connection-wide failures.
+     *
+     * `Subscribed` / `Unsubscribed` acks list only the channels a request
+     * changed, so a rejected channel is missing from the ack and reported by
+     * its own `Error` frame instead — this is how to pair the two, e.g. to
+     * resync only the channel whose snapshot was unavailable.
+     */
+    channel?: string;
 }
 /** Handler invoked for every `Error` frame the server sends. */
 export type ErrorHandler = (info: WebSocketErrorInfo) => void;
+/**
+ * Why the connection stopped reconnecting and needs fresh credentials.
+ * Delivered by {@link MonacoWebSocketConfig.onReauthenticationRequired}.
+ */
+export interface WebSocketReauthenticationInfo {
+    /**
+     * The `Error` frame code that ended the connection: `SESSION_INVALID` (the
+     * session was revoked or expired after the handshake) or `AUTH_FAILED` (the
+     * `Authenticate` handshake itself was rejected).
+     */
+    code: "SESSION_INVALID" | "AUTH_FAILED";
+    /** Human-readable description from the `Error` frame; for logging and display, never for branching. */
+    message: string;
+    /** WebSocket close code of the connection that was lost (1008 for `SESSION_INVALID`). */
+    closeCode: number;
+}
+/** Handler invoked when the connection lost its authentication terminally. */
+export type ReauthenticationRequiredHandler = (info: WebSocketReauthenticationInfo) => void;
 /**
  * Reconnect/resync knobs and callbacks for the Monaco WebSocket client.
  *
@@ -121,23 +153,47 @@ export interface MonacoWebSocketConfig {
     /**
      * Called for every `Error` frame the server sends on this connection.
      *
-     * `Error` frames are connection-scoped, not channel-scoped, so they reach no
-     * subscription handler — without this callback a failed subscribe, an
-     * invalidated session, or an unreadable subscribe-time snapshot is invisible
-     * to the app. Branch on `code`:
+     * `Error` frames match no subscription, so they reach no channel handler —
+     * without this callback a failed subscribe, an invalidated session, or an
+     * unreadable subscribe-time snapshot is invisible to the app. A failure
+     * caused by one requested channel additionally carries
+     * {@link WebSocketErrorInfo.channel}, the channel string this client sent;
+     * a connection-wide failure carries none. Branch on `code`:
      *
-     * - `SNAPSHOT_UNAVAILABLE` — live diffs flow but the baseline is missing;
-     *   refetch it. The subscription itself is fine.
-     * - `SESSION_INVALID` — re-authenticate rather than reconnect into the same
-     *   rejection.
-     * - `AUTH_REQUIRED` — a rejected SUBSCRIBE, not an invalidated session: the
-     *   channel was never registered, and this client still holds your handler,
-     *   so it treats the channel as subscribed and sends no new `Subscribe`.
-     *   Re-authenticating alone leaves it dead. Release the last handler for the
-     *   channel and subscribe again after authenticating (0XM-2644 tracks doing
-     *   this automatically).
+     * - `SNAPSHOT_UNAVAILABLE` — live diffs flow but that channel's baseline is
+     *   missing; refetch it for `channel` alone. The subscription itself is fine.
+     * - `SESSION_INVALID` — the session was revoked or expired; the connection
+     *   closes and {@link onReauthenticationRequired} follows. No `channel`.
+     * - `AUTH_REQUIRED` — a rejected SUBSCRIBE of `channel`, not an invalidated
+     *   session: it was never registered, and this client still holds your
+     *   handler, so it treats the channel as subscribed and sends no new
+     *   `Subscribe`. Re-authenticating alone leaves it dead. Release the last
+     *   handler for that channel and subscribe again after authenticating
+     *   (0XM-2644 tracks doing this automatically).
      */
     onError?: ErrorHandler;
+    /**
+     * Called once when the connection lost its authentication terminally: the
+     * server invalidated the session (`SESSION_INVALID`, then a 1008 close) or
+     * rejected this connection's `Authenticate` handshake (`AUTH_FAILED`).
+     *
+     * Reconnecting with the same credentials would only be rejected again, so
+     * the client does not reconnect automatically after either. It forgets the
+     * rejected session keypair, keeps your subscription handlers, and reports
+     * `"disconnected"`. Obtain a fresh session and pass it to
+     * `setSessionKeypair` (the SDK's `login` does this): the client reconnects,
+     * authenticates with it, resubscribes every held channel, and fires
+     * {@link onResync} so you can reconcile what was missed — also when
+     * {@link autoReconnect} is off. A session you already replaced before the
+     * close (e.g. from {@link onError}) is kept, and the client reconnects with
+     * it instead of calling this. Supply the fresh session rather than calling
+     * `connect()` first: a session-less socket re-sends user-specific channels
+     * unauthenticated, and the server rejects them with `AUTH_REQUIRED`.
+     *
+     * Every other abnormal close — including a 1008 for exceeding the message
+     * rate cap and a 1013 slow-client shed — keeps the backoff reconnect.
+     */
+    onReauthenticationRequired?: ReauthenticationRequiredHandler;
 }
 /**
  * Raw event message interface

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

@@ -7,8 +7,13 @@ import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalO
  * 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`.
+ *
+ * A `TRAILING_STOP` row adds two: `armed` when tracking begins (its
+ * `activationPrice` was reached, or immediately when none was set) and
+ * `ratcheted` on every move of its trigger, carrying the new `triggerPrice`
+ * and the `watermarkPrice` it was derived from (0XM-2827).
  */
-export type ConditionalOrderEventReason = "created" | "activated" | "cancelled" | "parent_cancelled" | "triggered" | "failed" | "oco_cancelled";
+export type ConditionalOrderEventReason = "created" | "activated" | "cancelled" | "parent_cancelled" | "triggered" | "failed" | "oco_cancelled" | "armed" | "ratcheted";
 /**
  * A conditional (TP/SL) order's current state.
  *
@@ -82,6 +87,29 @@ export interface ConditionalOrderEventData {
     cancelledAt?: string;
     expiresAt?: string;
     failureReason?: string;
+    /**
+     * `TRAILING_STOP` only: retracement in basis points behind the watermark.
+     * Absent (`null` on the wire) on TP/SL rows. Wire: `trail_bps`.
+     */
+    trailBps?: number;
+    /**
+     * `TRAILING_STOP` only: the mark level that starts tracking. Absent when the
+     * stop armed immediately. Wire: `activation_price`.
+     */
+    activationPrice?: string;
+    /**
+     * `TRAILING_STOP` only: best mark (highest for a long, lowest for a short)
+     * observed since arming — `triggerPrice` is derived from it and only ever
+     * moves in the position's favour. A `ratcheted` frame carries both. Absent
+     * until the first mark is observed after arming. Wire: `watermark_price`.
+     */
+    watermarkPrice?: string;
+    /**
+     * `TRAILING_STOP` only: when tracking began (ISO 8601). Absent while the
+     * stop is still waiting for `activationPrice` — `state` stays `ACTIVE` in
+     * both phases. Wire: `trail_armed_at`.
+     */
+    trailArmedAt?: string;
     /**
      * 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
@@ -89,6 +117,13 @@ export interface ConditionalOrderEventData {
      * snapshot builds the same shape with `"snapshot"` instead.
      */
     reason: string;
+    /**
+     * When the conditional order was created (ISO 8601): the same string REST
+     * returns as `createdAt` for this id, on live updates and snapshot rows
+     * alike. Always present from current servers; optional so a frame from an
+     * older deployment during a rolling release still parses. Wire: `created_at`.
+     */
+    createdAt?: string;
     updatedAt: string;
     /**
      * Opaque, compare-only revision counter for this conditional order's state —

package/dist/wire/schema.d.ts

@@ -2972,13 +2972,18 @@ export interface components {
             updatedAt?: string | null;
         };
         AttachPositionTpSlRequest: {
+            /**
+             * @description Trailing stop (0XM-2827). May be attached alone or alongside take_profit /
+             *      stop_loss; it never takes part in oco and coexists with fixed legs.
+             */
+            trailingStop?: components["schemas"]["TrailingStopLeg"] | null;
+            takeProfit?: components["schemas"]["TpSlLeg"];
+            stopLoss?: components["schemas"]["TpSlLeg"];
             /**
              * @description One-cancels-the-other. Defaults to false. When true, both take_profit and
              *      stop_loss are required and the sibling is cancelled after either triggers.
              */
             oco?: boolean | null;
-            takeProfit?: components["schemas"]["TpSlLeg"];
-            stopLoss?: components["schemas"]["TpSlLeg"];
         };
         AttachPositionTpSlResponse: {
             positionId?: string | null;
@@ -2986,6 +2991,7 @@ export interface components {
             stopLossOrderId?: string | null;
             status?: string | null;
             message?: string | null;
+            trailingStopOrderId?: string | null;
         };
         BatchCancelAllResponse: {
             /**
@@ -3191,7 +3197,7 @@ export interface components {
              */
             riskBucketId?: string | null;
             /**
-             * @description Decimal collateral to allocate into a new isolated risk bucket. When provided, the API creates the bucket ID and matching-engine persists the bucket through the durable log.
+             * @description Decimal collateral allocated as an order budget in a new isolated risk bucket. Fills commit their required margin and paid-fee funding to position backing; unfilled or unused order funds do not protect the position from liquidation. Use position margin adjustment to add liquidation protection. The API creates the bucket ID and the matching engine persists it through the durable log.
              * @example 1000
              */
             riskBucketCollateral?: string | null;
@@ -3691,6 +3697,17 @@ export interface components {
             version?: number | null;
             /** @description Present only when state is TRIGGERED: the execution outcome of the order this conditional fired into (triggeredOrderId) — status, filled quantity, volume-weighted average fill price, taker fees and fill time — read from that order at request time. Trigger price and fill price are different numbers: the trigger fires on the mark price and the leg then trades against the book, so a MARKET leg fills at least the half-spread plus its own impact away from triggerPrice, and a LIMIT leg may still be resting (SUBMITTED / PARTIALLY_FILLED) or have been cut by the protective band (CANCELLED with a terminalReason). Absent while waiting on the trigger, on the conditional_orders WebSocket frames, and in the rare case the triggered order cannot be read. */
             triggeredOrder?: components["schemas"]["TriggeredOrderSummary"] | null;
+            /**
+             * Format: int32
+             * @description TRAILING_STOP only: retracement in basis points behind the watermark.
+             */
+            trailBps?: number | null;
+            /** @description TRAILING_STOP only: mark level that starts tracking. Absent when the stop armed immediately. */
+            activationPrice?: string | null;
+            /** @description TRAILING_STOP only: best mark (highest for a long, lowest for a short) observed since arming. triggerPrice is derived from it and only ever moves in the position's favour. Absent until the first mark is observed after arming. */
+            watermarkPrice?: string | null;
+            /** @description TRAILING_STOP only: when tracking began. Absent while the stop is still waiting for activationPrice (state stays ACTIVE in both phases). */
+            trailArmedAt?: string | null;
         };
         CreateDelegatedSessionRequest: {
             /**
@@ -3814,7 +3831,7 @@ export interface components {
              */
             riskBucketId?: string | null;
             /**
-             * @description Decimal collateral to allocate into a new isolated risk bucket. When provided, the API creates the bucket ID and matching-engine persists the bucket through the durable log.
+             * @description Decimal collateral allocated as an order budget in a new isolated risk bucket. Fills commit their required margin and paid-fee funding to position backing; unfilled or unused order funds do not protect the position from liquidation. Use position margin adjustment to add liquidation protection. The API creates the bucket ID and the matching engine persists it through the durable log.
              * @example 1000
              */
             riskBucketCollateral?: string | null;
@@ -3866,6 +3883,8 @@ export interface components {
              * @enum {string|null}
              */
             selfTradePreventionMode?: "CANCEL_MAKER" | "CANCEL_TAKER" | "CANCEL_BOTH" | "SKIP" | null;
+            /** @description Trailing stop attached to this entry order (margin only). Arms only when the order fully fills; cancelled with the order otherwise. One per position. */
+            trailingStop?: components["schemas"]["ParentTrailingStopLeg"] | null;
         };
         CreateOrderResponse: {
             /**
@@ -3912,6 +3931,11 @@ export interface components {
              * @description Delegated agent UUID when submitted through a delegated session
              */
             delegationId?: string | null;
+            /**
+             * Format: uuid
+             * @description Conditional order id of the trailing stop attached to this entry order, when one was requested
+             */
+            trailingStopOrderId?: string | null;
         };
         CreateTwapOrderRequest: {
             /**
@@ -5453,22 +5477,16 @@ export interface components {
             unrealizedPnl?: string | null;
             realizedPnl?: string | null;
             /**
-             * @description Open ISOLATED rows: the position's current backing — its risk bucket's
-             *      allocated collateral adjusted by settled realized PnL and funding paid,
-             *      net of collateral reserved for the bucket's open orders, clamped at zero
-             *      (0XM-2558). Partial closes and partial liquidations shrink the posted
-             *      margin pro-rata while the realized loss stays in the bucket, so this,
-             *      not the posted margin, is the unrealized-return denominator. Not a hard
-             *      -100% bound: the liquidation trigger and liquidation_price measure the
-             *      bucket's whole equity, order reserves included, so with a resting order
-             *      the return can pass -100% by that order's earmark before liquidation
-             *      lands; a mark can gap past the backing before the asynchronous
-             *      liquidation; a fully drained bucket serves "0". Served from the live risk
-             *      engine; when only persisted state is reachable the value is gross of
-             *      order reserves. Open CROSS rows fall back to the position's posted
-             *      margin. Terminal rows: total initial margin allocated across the
-             *      position's reducing executions when available — the margin basis for
-             *      lifetime realized return.
+             * @description Open ISOLATED rows: principal committed to the filled position, adjusted
+             *      by settled realized PnL, fees and funding, clamped at zero. Collateral
+             *      allocated to unfilled orders is excluded. This is the unrealized-return
+             *      denominator and the same backing used by isolated liquidation. Placing,
+             *      cancelling or resizing an unfilled order does not add position backing.
+             *      A price gap can pass the backing before asynchronous liquidation occurs.
+             *      Live and persisted reads use the same position-principal basis.
+             *      Open CROSS rows: the position's posted margin. Terminal rows: total
+             *      initial margin allocated across the position's reducing executions when
+             *      available, used as the basis for lifetime realized return.
              */
             isolatedMargin?: string | null;
             leverage?: string | null;
@@ -5570,7 +5588,7 @@ export interface components {
             cumFees?: string | null;
             /**
              * Format: int64
-             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, does restamp the account's open positions), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
+             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, persists the account's snapshot and restamps the positions it changed), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. The version advances exactly when the row's versioned content changed at that sequence, a change undone within one persistence batch included; a position a command left unchanged keeps its version, so a RANKED live frame for an untouched sibling of a filled position can carry a higher version than the persisted row while describing identical content — rank it as newer, and nothing changes. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
              * @example 918342
              */
             version?: number | null;
@@ -6219,14 +6237,29 @@ export interface components {
             orders?: components["schemas"]["ConditionalOrder"][] | null;
             /**
              * Format: uint32
-             * @description Matching conditional orders. Exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so a caller with more matching conditional orders than the listing can page through reads the cap, not its lifetime total.
+             * @description Matching conditional orders in page-number (offset) mode: exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so a caller with more matching conditional orders than the listing can page through reads the cap, not its lifetime total. 0 in cursor (pageToken) mode, which runs no COUNT (AIP-158).
              * @example 3
              */
             total?: number | null;
-            /** Format: uint32 */
+            /**
+             * Format: uint32
+             * @deprecated
+             * @description Deprecated: current page number (legacy offset mode only; 0 in cursor mode)
+             */
             page?: number | null;
             /** Format: uint32 */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, minted only when a further page exists — the
+             *      read over-fetches one row to decide, so there is no "maybe more" state.
+             *      Empty on every page-number (legacy) response, and empty on the final
+             *      cursor page (including a full final page, since nothing follows it).
+             *      Follow it until it comes back empty; that empty token is the definitive
+             *      end of the walk, so no extra zero-row request is needed. Do not feed the
+             *      empty token back as `page_token` — an empty input `page_token` restarts
+             *      the walk from the newest row.
+             */
+            nextPageToken?: string | null;
         };
         ListDelegatedAgentOwnersResponse: {
             /** @description Owners that have an active delegation to the calling agent */
@@ -6435,13 +6468,14 @@ export interface components {
             orders?: components["schemas"]["TwapOrder"][] | null;
             /**
              * Format: uint32
-             * @description Matching TWAP orders. Exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so a caller with more matching TWAP orders than the listing can page through reads the cap, not its lifetime total.
+             * @description Matching TWAP orders in page-number (offset) mode: exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so a caller with more matching TWAP orders than the listing can page through reads the cap, not its lifetime total. 0 in cursor (pageToken) mode, which runs no COUNT (AIP-158).
              * @example 3
              */
             total?: number | null;
             /**
              * Format: uint32
-             * @description Current page number
+             * @deprecated
+             * @description Deprecated: current page number (legacy offset mode only; 0 in cursor mode)
              * @example 1
              */
             page?: number | null;
@@ -6451,6 +6485,17 @@ export interface components {
              * @example 20
              */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, minted only when a further page exists — the
+             *      read over-fetches one row to decide, so there is no "maybe more" state.
+             *      Empty on every page-number (legacy) response, and empty on the final
+             *      cursor page (including a full final page, since nothing follows it).
+             *      Follow it until it comes back empty; that empty token is the definitive
+             *      end of the walk, so no extra zero-row request is needed. Do not feed the
+             *      empty token back as `page_token` — an empty input `page_token` restarts
+             *      the walk from the newest row.
+             */
+            nextPageToken?: string | null;
         };
         ManagedMarketAssignment: {
             launchId?: string | null;
@@ -6723,6 +6768,46 @@ export interface components {
              */
             closePosition?: boolean | null;
         };
+        /**
+         * @description Trailing stop leg on an entry order (0XM-2827). Same ratchet semantics as
+         *      TrailingStopLeg on the position-attached rail: reduce-only MARKET close,
+         *      trigger trails the watermark by trail_bps in the position's favour, fires
+         *      through the standard conditional market close path.
+         */
+        ParentTrailingStopLeg: {
+            /**
+             * Format: int32
+             * @description Retracement in basis points behind the best mark reached since arming; integer, 10 to 2000 inclusive.
+             * @example 150
+             */
+            trailBps?: number | null;
+            /**
+             * @description Optional mark level that starts tracking once the entry has fully filled. Omit to start tracking at the first mark after the fill. Rejected at attach time if already met by the current mark.
+             * @example 66000
+             */
+            activationPrice?: string | null;
+            /**
+             * @description Deliberate partial size that never resizes. Mutually exclusive with closePosition; omit both to close the full live position at trigger time.
+             * @example 0.5
+             */
+            quantity?: string | null;
+            /**
+             * @description Resolve the full live position size when triggered. Mutually exclusive with quantity.
+             * @example true
+             */
+            closePosition?: boolean | null;
+            /**
+             * Format: int32
+             * @description Slippage cap in basis points for the triggered MARKET close (TP/SL parity).
+             * @example 1000
+             */
+            slippageToleranceBps?: number | null;
+            /**
+             * @description Optional expiry timestamp (ISO 8601)
+             * @example 2026-06-01T00:00:00Z
+             */
+            expiresAt?: string | null;
+        };
         /**
          * @description A single pending withdrawal in a list response. A lightweight summary — the
          *      executable calldata is not included (it does not exist until the withdrawal
@@ -7070,22 +7155,16 @@ export interface components {
             unrealizedPnl?: string | null;
             realizedPnl?: string | null;
             /**
-             * @description Open ISOLATED rows: the position's current backing — its risk bucket's
-             *      allocated collateral adjusted by settled realized PnL and funding paid,
-             *      net of collateral reserved for the bucket's open orders, clamped at zero
-             *      (0XM-2558). Partial closes and partial liquidations shrink the posted
-             *      margin pro-rata while the realized loss stays in the bucket, so this,
-             *      not the posted margin, is the unrealized-return denominator. Not a hard
-             *      -100% bound: the liquidation trigger and liquidation_price measure the
-             *      bucket's whole equity, order reserves included, so with a resting order
-             *      the return can pass -100% by that order's earmark before liquidation
-             *      lands; a mark can gap past the backing before the asynchronous
-             *      liquidation; a fully drained bucket serves "0". Served from the live risk
-             *      engine; when only persisted state is reachable the value is gross of
-             *      order reserves. Open CROSS rows fall back to the position's posted
-             *      margin. Terminal rows: total initial margin allocated across the
-             *      position's reducing executions when available — the margin basis for
-             *      lifetime realized return.
+             * @description Open ISOLATED rows: principal committed to the filled position, adjusted
+             *      by settled realized PnL, fees and funding, clamped at zero. Collateral
+             *      allocated to unfilled orders is excluded. This is the unrealized-return
+             *      denominator and the same backing used by isolated liquidation. Placing,
+             *      cancelling or resizing an unfilled order does not add position backing.
+             *      A price gap can pass the backing before asynchronous liquidation occurs.
+             *      Live and persisted reads use the same position-principal basis.
+             *      Open CROSS rows: the position's posted margin. Terminal rows: total
+             *      initial margin allocated across the position's reducing executions when
+             *      available, used as the basis for lifetime realized return.
              */
             isolatedMargin?: string | null;
             leverage?: string | null;
@@ -7187,7 +7266,7 @@ export interface components {
             cumFees?: string | null;
             /**
              * Format: int64
-             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: it means the row predates this field or came from a producer that does not stamp it, so treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, does restamp the account's open positions), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
+             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: it means the row predates this field or came from a producer that does not stamp it, so treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, persists the account's snapshot and restamps the positions it changed), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. The version advances exactly when the row's versioned content changed at that sequence, a change undone within one persistence batch included; a position a command left unchanged keeps its version, so a RANKED live frame for an untouched sibling of a filled position can carry a higher version than the persisted row while describing identical content — rank it as newer, and nothing changes. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
              * @example 918342
              */
             version?: number | null;
@@ -7805,6 +7884,21 @@ export interface components {
              * @example 1172836500.00
              */
             openInterestNotional?: string | null;
+            /**
+             * @description Arithmetic mean of the valued gross open-interest notional observations (one per completed UTC minute) over the last 60 completed minutes ending at floor(now to minute); published once at least 95% of those minutes (57) carry a valued sample. Null for spot pairs or below that coverage; a minute without a trade price is unvalued, never zero; known zero is "0". Each sample is gross open position size x latest trade price in quote units. No historical backfill; this window warms after deployment.
+             * @example 1172836500.00
+             */
+            openInterestNotionalAvg1h?: string | null;
+            /**
+             * @description Arithmetic mean of the valued gross open-interest notional observations (one per completed UTC minute) over the last 1440 completed minutes ending at floor(now to minute); published once at least 95% of those minutes (1368) carry a valued sample. Null for spot pairs or below that coverage; a minute without a trade price is unvalued, never zero; known zero is "0". Each sample is gross open position size x latest trade price in quote units. No historical backfill; this window warms after deployment.
+             * @example 1172836500.00
+             */
+            openInterestNotionalAvg24h?: string | null;
+            /**
+             * @description Arithmetic mean of the valued gross open-interest notional observations (one per completed UTC minute) over the last 10080 completed minutes ending at floor(now to minute); published once at least 95% of those minutes (9576) carry a valued sample. Null for spot pairs or below that coverage; a minute without a trade price is unvalued, never zero; known zero is "0". Each sample is gross open position size x latest trade price in quote units. No historical backfill; this window warms after deployment.
+             * @example 1172836500.00
+             */
+            openInterestNotionalAvg7d?: string | null;
         };
         /** @description One UTC-day bucket in a pair's 7-day snapshot. */
         ScreenerSnapshotPoint: {
@@ -7823,6 +7917,11 @@ export interface components {
              * @example 0.85
              */
             priceChangePercent?: string | null;
+            /**
+             * @description Arithmetic mean of the valued open-interest notional observations (one per completed UTC minute) in this completed UTC day; published once at least 95% of its 1440 minutes (1368) carry a valued sample, null for spot pairs or below that coverage. Samples use gross open position size x latest trade price in quote units; a minute without a trade price is unvalued, never zero; known zero remains "0". No historical backfill.
+             * @example 1172836500.00
+             */
+            openInterestNotionalAvg?: string | null;
         };
         SelfTradePreventionDefaultResponse: {
             /**
@@ -8524,6 +8623,41 @@ export interface components {
              */
             quoteAssetName?: string | null;
         };
+        /**
+         * @description Trailing stop leg (0XM-2827). Reduce-only MARKET close whose trigger trails
+         *      the best mark price reached since it armed (the "watermark") by `trail_bps`:
+         *      for a long, trigger = watermark x (1 - trail_bps/10000) and fires when mark
+         *      falls to or below it; for a short, trigger = watermark x (1 + trail_bps/10000)
+         *      and fires when mark rises to or above it. The trigger only ever moves in the
+         *      position's favour. One trailing stop per position; a second attach is
+         *      rejected with a conflict, never a replace. Fires through the same market
+         *      close path as a TP/SL (1,200 bps protective band, optional slippage cap).
+         */
+        TrailingStopLeg: {
+            /**
+             * Format: int32
+             * @description Retracement in basis points, integer, 10 to 2000 inclusive.
+             */
+            trailBps?: number | null;
+            /**
+             * @description Optional mark level that starts tracking. Omitted: tracking starts
+             *      immediately at the current mark. Present: rejected if the mark has
+             *      already reached it; once reached, the watermark seeds at this level.
+             */
+            activationPrice?: string | null;
+            /**
+             * @description Deliberate partial size; mutually exclusive with close_position. Omit both
+             *      to close the full live position at trigger time. Same contract as TpSlLeg.
+             */
+            quantity?: string | null;
+            closePosition?: boolean | null;
+            /**
+             * Format: int32
+             * @description Slippage cap for the triggered MARKET close, 0 to 10000 bps (TP/SL parity).
+             */
+            slippageToleranceBps?: number | null;
+            expiresAt?: string | null;
+        };
         TransferCollateralFromMarginAccountRequest: {
             /** @description Parent margin account UUID that releases collateral. */
             marginAccountId?: string | null;
@@ -13112,10 +13246,29 @@ export interface operations {
                 /** @description Trading pair identifier (UUID) */
                 tradingPairId?: string;
                 state?: string;
-                /** @description Page number (1-indexed) */
+                /**
+                 * @deprecated
+                 * @description Deprecated: page number for legacy offset pagination (1-indexed). Use pageToken cursor pagination instead.
+                 */
                 page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 100 in page-number mode; up to 1000 when pageToken is present) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with three distinct states:
+                 *       - Omitted: legacy page-number pagination via `page`.
+                 *       - Empty string (""): start a cursor walk with no prior position, from
+                 *         the newest conditional order.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `next_page_token`; results resume immediately after that position.
+                 *
+                 *      In either cursor-walk state (empty or non-empty), `page` is ignored and
+                 *      `total` is not populated — both come back 0, because cursor mode runs no
+                 *      COUNT (AIP-158). Cursor pages are keyset seeks on `(createdAt, id)`, so a
+                 *      page size up to 1000 is allowed. Filters must match the request that
+                 *      produced the token; a token replayed against different filters is
+                 *      rejected.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -13204,13 +13357,32 @@ export interface operations {
     list_twap_orders: {
         parameters: {
             query?: {
-                /** @description Page number (1-indexed) */
+                /**
+                 * @deprecated
+                 * @description Deprecated: page number for legacy offset pagination (1-indexed). Use pageToken cursor pagination instead.
+                 */
                 page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 100 in page-number mode; up to 1000 when pageToken is present) */
                 pageSize?: number;
                 state?: string;
                 /** @description Trading pair identifier (UUID) */
                 tradingPairId?: string;
+                /**
+                 * @description Pagination cursor with three distinct states:
+                 *       - Omitted: legacy page-number pagination via `page`.
+                 *       - Empty string (""): start a cursor walk with no prior position, from
+                 *         the newest TWAP parent.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `next_page_token`; results resume immediately after that position.
+                 *
+                 *      In either cursor-walk state (empty or non-empty), `page` is ignored and
+                 *      `total` is not populated — both come back 0, because cursor mode runs no
+                 *      COUNT (AIP-158). Cursor pages are keyset seeks on `(createdAt, id)`, so a
+                 *      page size up to 1000 is allowed. Filters must match the request that
+                 *      produced the token; a token replayed against different filters is
+                 *      rejected.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -14294,6 +14466,13 @@ export interface operations {
                     "application/json": components["schemas"]["AttachPositionTpSlResponse"];
                 };
             };
+            /** @description Order rate limit exceeded — each attach draws one item from the per-account order-creation budget it shares with order creates (and the budget the account family shares); retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     get_pulse: {