@0xmonaco/types 1.0.47 → 1.0.50-develop.9c1b239

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;
@@ -95,17 +131,43 @@ export interface TransferCollateralToParentMarginAccountRequest {
     asset: string;
     amount: string;
 }
+/**
+ * Fund a pair's isolated risk bucket from the parent margin account's
+ * unallocated collateral (no wallet movement; the bucket is created if
+ * needed). What the money becomes when the bucket holds an open position is
+ * stated by `applyToPositionMargin` — the two intents want opposite fates for
+ * the same dollars. Either way the liquidation cushion improves identically.
+ */
 export interface TransferCollateralToIsolatedRiskBucketRequest extends TransferCollateralToParentMarginAccountRequest {
     marginMode?: "ISOLATED";
     tradingPairId: string;
     strategyKey?: string;
     selectedTradingPairIds?: never;
+    /**
+     * `true` (and OMITTED — the default is the human "Adjust Margin" gesture):
+     * the amount is COMMITTED to the sole open position's stored margin.
+     * Effective leverage drops and stays down, initial margin required rises by
+     * the amount, free collateral is unchanged — new orders cannot spend it.
+     *
+     * `false`: plain allocation. Free collateral rises and the next order can
+     * spend it. Programmatic funding loops that top a bucket up to a free
+     * collateral target MUST pass `false`, or each top-up converts into
+     * requirement and the loop never converges.
+     *
+     * On a flat bucket both values are a plain allocation. The response's
+     * `positionMarginCredited` reports what actually happened — a credit can
+     * degrade to a plain allocation when the persisted position row is stale
+     * (close/reopen race).
+     */
+    applyToPositionMargin?: boolean;
 }
 export interface TransferCollateralToCrossRiskBucketRequest extends TransferCollateralToParentMarginAccountRequest {
     marginMode: "CROSS";
     selectedTradingPairIds: string[];
     tradingPairId?: never;
     strategyKey?: never;
+    /** Cross risk is pooled at bucket equity — there is no per-position margin; an explicit `true` is rejected. */
+    applyToPositionMargin?: never;
 }
 export type TransferCollateralToRiskBucketRequest = TransferCollateralToIsolatedRiskBucketRequest | TransferCollateralToCrossRiskBucketRequest;
 export interface TransferCollateralFromParentMarginAccountRequest {
@@ -125,6 +187,16 @@ export interface TransferCollateralResponse {
     newEquity: string;
     newTotalCollateralValue: string;
     newWithdrawableCollateral: string;
+    /**
+     * Whether the transfer was committed to a position's stored margin. Present
+     * only when a position-margin credit was in play: `true` — the credit
+     * landed; `false` — a credit was requested (or defaulted) but degraded to a
+     * plain allocation because the bucket's persisted position row was stale
+     * (close/reopen race) — re-issue the Adjust Margin once the new position
+     * row lands if the commitment still matters. Absent (never null) on plain
+     * allocations, parent deposits, and releases.
+     */
+    positionMarginCredited?: boolean;
 }
 export interface GetMarginAccountMovementsParams {
     movementType?: string;
@@ -201,8 +273,9 @@ export interface MarginAccountsAPI extends BaseAPI {
     getMarginAccountSummary(marginAccountId: string, params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
     getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
     /**
-     * @deprecated Prefer transferCollateralToParentMarginAccount() or
-     * transferCollateralToRiskBucket().
+     * @deprecated Use `transferCollateralToRiskBucket` for bucket funding
+     * (which now credits a sole open position's stored margin the same way) and
+     * `transferCollateralToParentMarginAccount` for wallet-to-margin deposits.
      */
     transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
     transferCollateralToParentMarginAccount(request: TransferCollateralToParentMarginAccountRequest): Promise<TransferCollateralResponse>;

package/dist/portfolio/index.d.ts

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

package/dist/sdk/index.d.ts

@@ -109,7 +109,7 @@ export interface MonacoSDK {
     pitpass: PitpassAPI;
     /** Testnet faucet API */
     faucet: FaucetAPI;
-    /** Public deposit-address registration (sweeper) API */
+    /** Deposit-address registration (sweeper) API; requires a session */
     sweeper: SweeperAPI;
     /** Public whitelist (waitlist) submission API */
     whitelist: WhitelistAPI;

package/dist/sweeper/index.d.ts

@@ -1,43 +1,59 @@
 /**
  * Sweeper Types
  *
- * Types for the public deposit-address registration endpoint. Wire shapes are
+ * Types for the deposit-address registration endpoint. Wire shapes are
  * snake_case; these are the camelCase ergonomic forms.
  *
- * NOTE: This endpoint is **public (unauthenticated)**. The deposit address is
- * derived from the (application, user) pair and its destination is fixed in the
- * contract's own bytecode, so a caller can only ever route funds to the user
- * they already belong to. Abuse is bounded by a per-client rate limit and an
- * active-application check instead of authentication.
+ * NOTE: This endpoint is **authenticated**. The credited address is the calling
+ * session's own rather than a request field, so a caller can only ever register
+ * an address they hold the session key for.
  */
+import type { DepositTarget } from "@0xmonaco/contracts";
 import type { BaseAPI } from "../api";
 /**
  * What happened to the registration.
  *
- * - `registered` — the pair was added; its deposit address is now monitored.
- * - `already_registered` — the pair was known before this call; nothing was
+ * - `registered` — the triple was added; its deposit address is now monitored.
+ * - `already_registered` — the triple was known before this call; nothing was
  *   re-triggered.
  */
 export type RegisterSweeperStatus = "registered" | "already_registered";
-/** Body for a deposit-address registration. */
+/**
+ * Body for a deposit-address registration.
+ *
+ * Deliberately tiny: the application and the credited address both come from
+ * the authenticated session (`login` takes the application's client id), so the
+ * only thing left to say is which ledger to aim at.
+ */
 export interface RegisterSweeperRequest {
     /**
-     * The application's client id — the same identifier rollup deposits carry
-     * and `login` takes. The deposit address is derived from these exact bytes
-     * and the application lookup is an exact string match, so the spelling must
-     * match the registered application precisely.
+     * Which ledger swept deposits ask to be credited to. Defaults to `"spot"`.
+     *
+     * `"margin"` asks for the parent margin account's collateral, skipping the
+     * separate `transferCollateralToParentMarginAccount` step. The target is part
+     * of the address derivation, so the two targets yield two different deposit
+     * addresses for the same pair, each carrying its own request. A `"spot"`
+     * address is never credited to margin.
+     *
+     * `"margin"` is a request rather than a guarantee: a deposit the backend
+     * cannot route to collateral — an unsupported collateral asset, or a margin
+     * account that fails validation — is credited to the spot wallet instead, so
+     * funds are never stranded. Read the balance back rather than treating the
+     * address as proof of where the credit landed.
+     *
+     * An unrecognized value is rejected (400) rather than falling back to spot,
+     * which would return an address pointed at a ledger the caller did not ask
+     * for.
      */
-    clientId: string;
-    /** Address credited on the rollup, and half of the deposit-address derivation */
-    userAddress: string;
+    depositTarget?: DepositTarget;
 }
 /** Result of a deposit-address registration. */
 export interface RegisterSweeperResponse {
-    /** Whether this call added the pair or it was known before */
+    /** Whether this call added the triple or it was known before */
     status: RegisterSweeperStatus;
     /**
-     * The pair's deposit address. Stable, and valid to publish and fund before
-     * any contract exists there.
+     * The deposit address for this (application, user, deposit target) triple.
+     * Stable, and valid to publish and fund before any contract exists there.
      */
     sweeperAddress: string;
     /**
@@ -48,20 +64,26 @@ export interface RegisterSweeperResponse {
     initialSweepCheck: boolean;
 }
 /**
- * Sweeper API interface. The register endpoint is public (no auth required).
+ * Sweeper API interface. The register endpoint requires authentication.
  */
 export interface SweeperAPI extends BaseAPI {
     /**
-     * Registers an (application, user) pair so its deterministic deposit
-     * address is monitored and every ERC20 deposit is swept into the rollup
-     * automatically.
+     * Registers an (application, user, deposit target) triple so its
+     * deterministic deposit address is monitored and every ERC20 deposit is
+     * swept into the rollup automatically.
+     *
+     * The application and the credited address both come from the authenticated
+     * session, so this only ever registers the caller's own address under their
+     * own application. Call it with no arguments for a spot address.
      *
      * Returns immediately with the derived deposit address; the one-time
      * initial balance check runs in the background. Idempotent and safe to
      * retry: re-registering answers `already_registered` with the same address
-     * and never re-triggers the initial check. An unknown client id — any
-     * respelling of a real one included, the lookup is exact — throws (404),
-     * and registrations are lightly rate-limited per client (429).
+     * and never re-triggers the initial check.
+     *
+     * Throws on an unrecognized `depositTarget` (before sending), when the
+     * session's application is no longer active (403), and when the endpoint's
+     * global admission limit is exceeded (429).
      */
-    register(body: RegisterSweeperRequest): Promise<RegisterSweeperResponse>;
+    register(body?: RegisterSweeperRequest): Promise<RegisterSweeperResponse>;
 }

package/dist/sweeper/index.js

@@ -1,12 +1,10 @@
 /**
  * Sweeper Types
  *
- * Types for the public deposit-address registration endpoint. Wire shapes are
+ * Types for the deposit-address registration endpoint. Wire shapes are
  * snake_case; these are the camelCase ergonomic forms.
  *
- * NOTE: This endpoint is **public (unauthenticated)**. The deposit address is
- * derived from the (application, user) pair and its destination is fixed in the
- * contract's own bytecode, so a caller can only ever route funds to the user
- * they already belong to. Abuse is bounded by a per-client rate limit and an
- * active-application check instead of authentication.
+ * NOTE: This endpoint is **authenticated**. The credited address is the calling
+ * session's own rather than a request field, so a caller can only ever register
+ * an address they hold the session key for.
  */

package/dist/trading/orders.d.ts

@@ -168,6 +168,11 @@ export type ConditionalOrderState = "PENDING_PARENT" | "ACTIVE" | "TRIGGERING" |
  * - ACTIVE: inside the execution window; child slices are firing
  * - COMPLETED: window ended (fully filled or hard-stopped with a shortfall)
  * - CANCELLED: cancelled by the user before the window ended
+ *
+ * These are the values the server sends today, not a runtime guarantee:
+ * `@0xmonaco/core` parses the `twap_orders` WebSocket frame leniently, so a
+ * state added server-side after this version ships is delivered as-is rather
+ * than dropping the update (0XM-2628). Match it with a default branch.
  */
 export type TwapOrderState = "PENDING" | "ACTIVE" | "COMPLETED" | "CANCELLED";
 /**

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

@@ -45,6 +45,7 @@ export declare const TransferCollateralToRiskBucketSchema: z.ZodObject<{
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
+        applyToPositionMargin: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
         asset: z.ZodString;
         amount: z.ZodString;
@@ -139,6 +140,7 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
+        applyToPositionMargin: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
         tradingPairId: z.ZodUUID;
         side: z.ZodEnum<{

package/dist/validation/margin-accounts.js

@@ -51,6 +51,10 @@ const SelectedCrossTradingPairIdsSchema = z.array(UUIDSchema).min(1, "selectedTr
 const IsolatedRiskBucketRequestSchema = RiskBucketRequestSchema.extend({
     marginMode: z.literal("ISOLATED").optional(),
     selectedTradingPairIds: z.never().optional(),
+    // Omitted defaults server-side to true (the Adjust Margin gesture); false
+    // is the plain allocation programmatic funding loops need. The CROSS form
+    // stays strict-rejected (no per-position margin to commit to).
+    applyToPositionMargin: z.boolean().optional(),
 });
 const CrossRiskBucketScopeSchema = z.object({
     marginMode: z.literal("CROSS"),

package/dist/vault/index.d.ts

@@ -3,6 +3,7 @@
  *
  * Types for vault operations including deposits, withdrawals, and balance management.
  */
+import type { DepositTarget } from "@0xmonaco/contracts";
 import type { Address } from "viem";
 import type { BaseAPI } from "../api/index";
 import type { Balance, TransactionResult, WithdrawalRetryOptions, WithdrawResult } from "./responses";
@@ -13,8 +14,13 @@ import type { Balance, TransactionResult, WithdrawalRetryOptions, WithdrawResult
  *   collateral (auto-creating the account if it does not exist yet). A deposit
  *   that cannot be routed to margin (unsupported asset, etc.) safely falls back
  *   to spot — funds are never lost.
+ *
+ * Re-exported from `@0xmonaco/contracts` rather than redeclared: the same
+ * value selects the on-chain routing hint for a direct deposit and the
+ * derivation of a sweeper deposit address, so one definition keeps the two
+ * from drifting into separately-maintained unions.
  */
-export type DepositTarget = "spot" | "margin";
+export type { DepositTarget };
 /**
  * Options for a deposit.
  */

package/dist/websocket/base.d.ts

@@ -29,6 +29,55 @@ export interface WebSocketResyncInfo {
 }
 /** Handler invoked after a reconnect resumes the live stream. */
 export type ResyncHandler = (info: WebSocketResyncInfo) => void;
+/**
+ * Machine-readable classification the server puts on every `Error` frame so a
+ * client can branch on the failure without string-matching the human message.
+ * Mirrors `ws-api`'s `WsErrorCode` enum, whose SCREAMING_SNAKE_CASE wire
+ * strings are pinned on the Rust side in `ws-api/src/websocket/protocol.rs`
+ * and cross-checked against this union by `@0xmonaco/core`'s
+ * `websocket-enum-parity` test.
+ */
+export type WebSocketErrorCode = 
+/** A user-specific channel was subscribed before authenticating. */
+"AUTH_REQUIRED"
+/** The `Authenticate` handshake was rejected; the connection is closed after this frame. */
+ | "AUTH_FAILED"
+/** The per-user concurrent-connection cap was reached; this connection is closed after the frame. */
+ | "CONNECTION_LIMIT"
+/** The per-connection subscription-cardinality cap was reached. */
+ | "SUBSCRIPTION_LIMIT"
+/** A subscription request was malformed or failed parameter validation. */
+ | "INVALID_SUBSCRIPTION"
+/** An inbound frame could not be parsed, or an unsupported frame type was sent. */
+ | "INVALID_MESSAGE"
+/**
+ * A previously-authenticated session became invalid after the handshake
+ * (revoked, expired, or the account was banned/deactivated). Re-authenticate
+ * rather than blindly reconnecting into the same rejection.
+ */
+ | "SESSION_INVALID"
+/**
+ * The subscribe-time snapshot could not be read. The subscription is still
+ * active and live diffs flow, but the baseline is missing — refetch it (e.g.
+ * from REST) rather than assuming the stream started from a coherent state.
+ */
+ | "SNAPSHOT_UNAVAILABLE";
+/**
+ * An `Error` frame the server sent on this connection.
+ *
+ * `code` is widened past {@link WebSocketErrorCode} on purpose: a code added
+ * server-side after this SDK version shipped is delivered as-is rather than
+ * dropped, so an older client still sees that something failed and can log it.
+ * Narrow with a `switch` on the known values and treat the default as unknown.
+ */
+export interface WebSocketErrorInfo {
+    /** Stable classification of the failure. */
+    code: WebSocketErrorCode | (string & {});
+    /** Human-readable description; for logging and display, never for branching. */
+    message: string;
+}
+/** Handler invoked for every `Error` frame the server sends. */
+export type ErrorHandler = (info: WebSocketErrorInfo) => void;
 /**
  * Reconnect/resync knobs and callbacks for the Monaco WebSocket client.
  *
@@ -62,6 +111,26 @@ export interface MonacoWebSocketConfig {
      * the snapshot was in flight are newer than the snapshot rows they duplicate.
      */
     onResync?: ResyncHandler;
+    /**
+     * 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`:
+     *
+     * - `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).
+     */
+    onError?: ErrorHandler;
 }
 /**
  * Raw event message interface

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

@@ -42,11 +42,14 @@ export interface AccountEventData {
     freeCollateral: string;
     /**
      * Account distress ratio: maintenance margin required over equity (higher is
-     * closer to liquidation, decimal string). When equity is non-positive the
-     * quotient is undefined, so an account that still owes a maintenance
-     * requirement saturates to the max-decimal sentinel
-     * (`79228162514264337593543950335`, maximal distress) and an empty account
-     * with no requirement is `0`. Clamp the sentinel before display.
+     * closer to liquidation, decimal string). The quotient saturates to the
+     * max-decimal sentinel (`79228162514264337593543950335`, maximal distress)
+     * whenever it cannot be computed or represented: an account still owing a
+     * maintenance requirement at zero or negative equity, and equally at
+     * near-zero POSITIVE equity where the true ratio exceeds the decimal range.
+     * An empty account with no requirement is `0`. Clamp the sentinel before
+     * display; treat any value at or above the liquidation threshold as maximal
+     * distress rather than distinguishing the sentinel's causes.
      */
     marginRatio: string;
     /** Maintenance margin required to keep the account solvent (decimal string) */

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

@@ -1,32 +1,94 @@
 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** — 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
+ * 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;
     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;
-    orderType: OrderType;
+    side: OrderSide | (string & {});
+    positionSide: PositionSide | (string & {});
+    /**
+     * 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 | (string & {});
     limitPrice?: string;
     quantity?: string;
     slippageToleranceBps?: number;
     reduceOnly: boolean;
-    timeInForce?: Extract<TimeInForce, "GTC" | "IOC">;
-    state: ConditionalOrderState;
+    /**
+     * 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 | (string & {});
+    state: ConditionalOrderState | (string & {});
     triggeredOrderId?: string;
     triggeredAt?: string;
     activatedAt?: string;
     cancelledAt?: string;
     expiresAt?: string;
     failureReason?: string;
-    reason: ConditionalOrderEventReason;
+    /**
+     * What produced this update. Free-form on the wire — the server field is a
+     * plain string, not an enum — but a live update's canonical values are the
+     * ones listed on {@link ConditionalOrderEventReason}. The subscribe-time
+     * snapshot builds the same shape with `"snapshot"` instead.
+     */
+    reason: string;
     updatedAt: string;
 }
 export interface ConditionalOrderEvent {

package/dist/websocket/events/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 */