@0xmonaco/types 1.0.88 → 1.0.90

package/dist/wire/schema.d.ts

@@ -2202,6 +2202,48 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/market/pairs/{tradingPairId}/liquidation-events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Liquidation Events
+         * @description Stored liquidation events for one market. Wallet-addressed events are
+         *      newest-first and keyset-paged; event and side-summary reads remain
+         *      separate so clients can fetch either surface independently.
+         */
+        get: operations["list_liquidation_events"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/market/pairs/{tradingPairId}/liquidation-metrics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Liquidation Metrics
+         * @description UTC-aligned long/short liquidation totals for a bounded market time range.
+         */
+        get: operations["get_liquidation_metrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/market/pairs/{tradingPairId}/mark-price": {
         parameters: {
             query?: never;
@@ -2297,6 +2339,46 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/market/pairs/{tradingPairId}/trade-flow": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Trade Flow
+         * @description Bounded quote-notional taker flow and cumulative volume delta for a perp.
+         */
+        get: operations["get_trade_flow"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/market/pairs/{tradingPairId}/trader-metrics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Trader Metrics
+         * @description Current public trader positioning and participation aggregates for a perp.
+         */
+        get: operations["get_trader_metrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/market/screener": {
         parameters: {
             query?: never;
@@ -2969,6 +3051,85 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/sweeper/deposits": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the caller's sweeper deposits, newest first
+         * @description The caller's sweeper deposits, newest first.
+         *
+         *      Every transfer into one of the caller's deposit addresses, on any
+         *      supported chain, as the same `SweeperDeposit` entries
+         *      `get_sweeper_deposit_status` returns — so a client that has lost a
+         *      deposit's transaction hash can still find it and follow it. A swept CCTP
+         *      deposit is listed once, by its source-chain transfer: its hub mint is the
+         *      same deposit's second leg, not a deposit of its own. A burn made straight
+         *      to the hub deposit address has no source-chain transfer to the address,
+         *      so it is listed by its hub mint.
+         *
+         *      Newest recorded first, walked by an opaque cursor: omit `pageToken` (or
+         *      send `""`) to start, then pass each response's `nextPageToken` until it
+         *      comes back empty. A shorter page proves the end; the token is pinned to
+         *      this listing and position-only — the caller always comes from the session.
+         *
+         *      Authenticated: only deposits credited to the session's own address.
+         */
+        get: operations["list_sweeper_deposits"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/sweeper/deposits/{txHash}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get the status of the caller's sweeper deposits in one transaction
+         * @description Where the caller's sweeper deposits made by one transaction are.
+         *
+         *      Look a deposit up by the hash of the transaction that sent funds to one of
+         *      the caller's deposit addresses, on any supported chain. One transaction
+         *      can carry several such transfers, so the answer is a list (in chain, then
+         *      log order); it is empty until the sweeper has indexed the transaction, and
+         *      never includes deposits to anyone else's address.
+         *
+         *      Each deposit moves through `RECEIVED` (indexed; not yet swept — a balance
+         *      below the asset's minimum waits for a later deposit) and then, on the hub
+         *      chain, straight to `DEPOSITED` when the sweep lands. A deposit on another
+         *      chain is bridged by CCTP: `BURNED` (swept off the source chain),
+         *      `ATTESTING` (waiting for Circle's attestation), `ATTESTED`, `SETTLING`
+         *      (minted on the hub, being swept into the exchange) and `DEPOSITED`.
+         *      `FAILED` means the sweep returned the funds to the depositor's wallet
+         *      (`failureReason` `REFUNDED`): the exchange was paused, the user is blocked,
+         *      or the token is not accepted.
+         *
+         *      Sweeps move balances rather than individual transfers, so a sweep that
+         *      collected several deposits is attributed to each of them first in, first
+         *      out. Deposits bridged by a route other than CCTP stay at `BURNED`.
+         *
+         *      Authenticated: the deposits returned are those credited to the session's
+         *      own address.
+         */
+        get: operations["get_sweeper_deposit_status"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/sweeper/register": {
         parameters: {
             query?: never;
@@ -3503,6 +3664,30 @@ export interface components {
              */
             version?: number | null;
         };
+        ActiveTraderWindow: {
+            /**
+             * @description Rolling window ending at asOf: 1h, 24h, or 7d
+             * @example 24h
+             */
+            window?: string | null;
+            /**
+             * Format: int64
+             * @description Distinct maker or taker user IDs in executed trade records in this window, including system IDs on liquidation and ADL fills; all counts are null when this window is suppressed
+             */
+            activeTraderCount?: number | null;
+            /**
+             * Format: int64
+             * @description Distinct taker buyer user IDs in executed trade records in this window, including system IDs on liquidation and ADL fills; all counts are null when this window is suppressed
+             */
+            takerBuyerCount?: number | null;
+            /**
+             * Format: int64
+             * @description Distinct taker seller user IDs in executed trade records in this window, including system IDs on liquidation and ADL fills; all counts are null when this window is suppressed
+             */
+            takerSellerCount?: number | null;
+            /** @description True when any user count in this window is below five; all counts in the window are then null */
+            suppressed?: boolean | null;
+        };
         AddFollowPositionMarginRequest: {
             /**
              * Format: uuid
@@ -5045,7 +5230,7 @@ export interface components {
              */
             useMasterBalance?: boolean | null;
             /**
-             * @description Client-assigned idempotency key (max 36 chars), unique per user and application. A duplicate is rejected with 409.
+             * @description Client-assigned idempotency key (max 36 chars), unique per user and application while the parent is live and for a reservation lifetime after it ends (30 days by default, operator-configurable). A duplicate inside that window is rejected with 409; after it the key may be used again.
              * @example oms-3f6a1c
              */
             clientTwapId?: string | null;
@@ -5726,6 +5911,10 @@ export interface components {
              */
             clientId?: string | null;
         };
+        GetDepositStatusResponse: {
+            /** @description The caller's deposits made by the transaction, in chain then log order; empty until the sweeper has indexed it */
+            deposits?: components["schemas"]["SweeperDeposit"][] | null;
+        };
         GetFaucetInfoResponse: {
             /**
              * Format: uint32
@@ -5807,6 +5996,36 @@ export interface components {
         GetLimitsResponse: {
             limits?: components["schemas"]["SubAccountLimit"][] | null;
         };
+        /** @description Populated UTC-aligned buckets of long/short liquidation totals. Buckets with no events on either side are omitted. */
+        GetLiquidationMetricsResponse: {
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             */
+            tradingPairId?: string | null;
+            /**
+             * @description Quote asset denomination for mark notionals; no USD FX conversion
+             * @example USDC
+             */
+            quoteAssetSymbol?: string | null;
+            /**
+             * @description UTC-aligned bucket size
+             * @example 5m
+             */
+            interval?: string | null;
+            /**
+             * Format: int64
+             * @description Inclusive selected range start as Unix milliseconds
+             */
+            startTime?: number | null;
+            /**
+             * Format: int64
+             * @description Exclusive selected range end as Unix milliseconds
+             */
+            endTime?: number | null;
+            /** @description Populated UTC-aligned buckets; intervals with no events are omitted. */
+            buckets?: components["schemas"]["LiquidationMetricsBucket"][] | null;
+        };
         GetMarginAccountMovementsResponse: {
             movements?: components["schemas"]["MarginAccountMovement"][] | null;
             /** Format: uint32 */
@@ -6400,7 +6619,7 @@ export interface components {
             postOnly?: boolean | null;
             /**
              * Format: int64
-             * @description Opaque, compare-only revision counter for this order's state: the sequencer step that wrote it. A strictly higher value is strictly newer state for that order. The SAME counter is carried on every order WebSocket event and on the `orders` snapshot frame, so a reconnecting client reconciles on `(id, version)` — take the REST row when `snapshot.version >= local.version`, else keep local state. Note `>=`, not `>`: on the stream, equal versions mean the SAME STEP rather than identical state, because one step emits several events for one order (an `OrderPlaced` and then its fills) and a batch shares one step across every item. A REST row is that step's FINAL state, so it wins a tie. Between two REST reads the comparison is simpler — equal there does mean identical state. Do not read anything else into the number: it is not a count of updates, consecutive values are not expected (it is drawn from a global sequence shared by every order, so per-order values are sparse and gaps are normal), and it is not comparable across different orders. Absent means unknown: an order last written before this field existed. Fall back to a full field comparison for those rather than treating absent as version zero — and note that a comparison against an absent value is false in both directions, so an order held locally without one is never refreshed by the merge above; take the REST row unconditionally for those. Reconciling on this counter does NOT on its own close a reconnect gap: an order that filled or was cancelled while the socket was down appears in neither the resting snapshot nor the stream, so recover fills from `listUserTrades` (ordered by execution time) and resolve anything your local state believes is resting that the snapshot no longer lists with a targeted `getOrder`. Unlike `updatedAt`, this value is identical on every REST endpoint that serves the same order state, and never advances without a state change.
+             * @description Opaque, compare-only revision counter for this order's state: the sequencer step that wrote it. A strictly higher value is strictly newer state for that order. The SAME counter is carried on every order WebSocket event and on the `orders` snapshot frame, so a reconnecting client reconciles on `(id, version)` — take the REST row when `snapshot.version >= local.version`, else keep local state. Note `>=`, not `>`: on the stream, equal versions mean the SAME STEP rather than identical state, because one step emits several events for one order (an `OrderPlaced` and then its fills) and a batch shares one step across every item. A REST row is that step's FINAL state, so it wins a tie. Between two REST reads the comparison is simpler — equal there does mean identical state. Do not read anything else into the number: it is not a count of updates, consecutive values are not expected (it is drawn from a global sequence shared by every order, so per-order values are sparse and gaps are normal), and it is not comparable across different orders. Absent means unknown: an order last written before this field existed. Fall back to a full field comparison for those rather than treating absent as version zero — and note that a comparison against an absent value is false in both directions, so an order held locally without one is never refreshed by the merge above; take the REST row unconditionally for those. Reconciling on this counter does NOT on its own close a reconnect gap: an order that filled or was cancelled while the socket was down appears in neither the resting snapshot nor the stream, so recover fills from `getUserTrades` (`GET /api/v1/accounts/trades`, newest first) and resolve anything your local state believes is resting that the snapshot no longer lists with a targeted `getOrder`. Unlike `updatedAt`, this value is identical on every REST endpoint that serves the same order state, and never advances without a state change.
              * @example 918342
              */
             version?: number | null;
@@ -6505,6 +6724,11 @@ export interface components {
             /** @description The market's full margin ladder, ascending by lowerBoundNotional and always non-empty (a market with no configured brackets reports a single tier). A position's bracket is the LAST tier whose lowerBoundNotional is at or below its notional, abs(quantity) x markPrice. */
             riskTiers?: components["schemas"]["RiskTier"][] | null;
             updatedAt?: string | null;
+            /**
+             * @description Quote notional Q_m that each funding premium sample walks through each side of the book to read the market's impact bid and impact ask. Set per market; markets start at 2000.
+             * @example 2000
+             */
+            fundingImpactNotional?: string | null;
         };
         GetPerpMarketSummaryResponse: {
             /** Format: uuid */
@@ -7061,6 +7285,36 @@ export interface components {
              */
             tradingMode?: string | null;
         };
+        /** @description Taker buy/sell quote notional, net flow and cumulative volume delta for a bounded time range. All executed trades, including liquidation and ADL fills, are included. Empty buckets are omitted. Buckets that closed more than two minutes before the request may be served from a per-replica cache for up to ten minutes. */
+        GetTradeFlowResponse: {
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             */
+            tradingPairId?: string | null;
+            /**
+             * @description Quote asset used for all notional values, with no USD conversion
+             * @example USDC
+             */
+            quoteAssetSymbol?: string | null;
+            /**
+             * @description UTC-aligned bucket size
+             * @example 5m
+             */
+            interval?: string | null;
+            /**
+             * Format: int64
+             * @description Inclusive selected start time as Unix milliseconds
+             */
+            startTime?: number | null;
+            /**
+             * Format: int64
+             * @description Exclusive selected end time as Unix milliseconds
+             */
+            endTime?: number | null;
+            /** @description Populated UTC-aligned buckets; intervals without trades are omitted. */
+            buckets?: components["schemas"]["TradeFlowBucket"][] | null;
+        };
         GetTraderCodeInfoResponse: {
             /**
              * @description The resolved TraderCode (normalized wallet address)
@@ -7068,6 +7322,45 @@ export interface components {
              */
             code?: string | null;
         };
+        /** @description Current public long/short account positioning and active trader aggregates. Accounts are classified by net position across OPEN risk buckets. Account identifiers are never returned; position metrics are null when either side has fewer than five accounts. Responses may be reused from a per-pair cache for up to 30 seconds. */
+        GetTraderMetricsResponse: {
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             */
+            tradingPairId?: string | null;
+            /**
+             * @description Quote asset symbol for this trading pair
+             * @example USDC
+             */
+            quoteAssetSymbol?: string | null;
+            /**
+             * Format: int64
+             * @description Snapshot calculation time in Unix milliseconds
+             * @example 1736742000000
+             */
+            asOf?: number | null;
+            /** @description True when either net-long or net-short side has fewer than five margin accounts; all position split fields are then null */
+            positionMetricsSuppressed?: boolean | null;
+            /**
+             * Format: int64
+             * @description Distinct margin accounts with positive net position across OPEN risk buckets; null when suppressed
+             */
+            longAccountCount?: number | null;
+            /**
+             * Format: int64
+             * @description Distinct margin accounts with negative net position across OPEN risk buckets; null when suppressed
+             */
+            shortAccountCount?: number | null;
+            /** @description Long account count divided by long plus short account counts, rounded to six decimal places; null when suppressed */
+            longAccountShare?: string | null;
+            /** @description Short account count divided by long plus short account counts, rounded to six decimal places; null when suppressed */
+            shortAccountShare?: string | null;
+            /** @description Net-long account count divided by net-short account count, rounded to six decimal places; null when suppressed */
+            accountRatio?: string | null;
+            /** @description Active-trader counts grouped by rolling time window. */
+            activeTraderWindows?: components["schemas"]["ActiveTraderWindow"][] | null;
+        };
         /** @description Recent trades for a trading pair. */
         GetTradesResponse: {
             trades?: components["schemas"]["PublicTrade"][] | null;
@@ -7552,6 +7845,86 @@ export interface components {
              */
             earned?: string | null;
         };
+        /** @description One public per-position liquidation event. markNotional is positionSize multiplied by the mark price captured with the event, in quote-asset units. */
+        LiquidationEvent: {
+            /**
+             * Format: uuid
+             * @description Stable identifier of the stored liquidation event; use it to deduplicate REST backfills and WebSocket updates
+             */
+            eventId?: string | null;
+            /**
+             * Format: int64
+             * @description Event time as Unix milliseconds
+             * @example 1736742000123
+             */
+            timestamp?: number | null;
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             */
+            tradingPairId?: string | null;
+            /**
+             * @description Public wallet address associated with the liquidated position
+             * @example 0x1234567890abcdef1234567890abcdef12345678
+             */
+            wallet?: string | null;
+            /**
+             * @description Liquidated position side: LONG or SHORT
+             * @example LONG
+             * @enum {string|null}
+             */
+            side?: "LONG" | "SHORT" | null;
+            /**
+             * @description Absolute position size in base-asset units
+             * @example 0.25
+             */
+            positionSize?: string | null;
+            /**
+             * @description Mark price captured for this event, in quote units per base unit
+             * @example 95410.25
+             */
+            markPrice?: string | null;
+            /**
+             * @description Position size multiplied by the event-time mark price, in quote-asset units; no USD FX conversion
+             * @example 23852.5625
+             */
+            markNotional?: string | null;
+            /**
+             * @description Quote asset denomination of markNotional
+             * @example USDC
+             */
+            quoteAssetSymbol?: string | null;
+        };
+        LiquidationMetricsBucket: {
+            /**
+             * Format: int64
+             * @description UTC-aligned bucket start as Unix milliseconds
+             * @example 1736742000000
+             */
+            bucketStart?: number | null;
+            /** @description Long-side totals; zero-valued when the bucket has no long-side events */
+            long?: components["schemas"]["LiquidationSideMetrics"] | null;
+            /** @description Short-side totals; zero-valued when the bucket has no short-side events */
+            short?: components["schemas"]["LiquidationSideMetrics"] | null;
+        };
+        LiquidationSideMetrics: {
+            /**
+             * Format: int64
+             * @description Number of stored liquidation-event rows for this position side in the bucket; not a unique-wallet count
+             * @example 12
+             */
+            eventCount?: number | null;
+            /**
+             * @description Sum of event position sizes in base-asset units
+             * @example 3.75
+             */
+            positionSize?: string | null;
+            /**
+             * @description Sum of each event's positionSize multiplied by its event-time markPrice, in quote-asset units
+             * @example 358163.4375
+             */
+            markNotional?: string | null;
+        };
         ListAllFundingHistoryResponse: {
             records?: components["schemas"]["FundingRecord"][] | null;
             /**
@@ -7729,6 +8102,12 @@ export interface components {
             /** @description The calling owner's delegated agents */
             agents?: components["schemas"]["DelegatedAgent"][] | null;
         };
+        ListDepositsResponse: {
+            /** @description This page of the caller's deposits, newest recorded first */
+            deposits?: components["schemas"]["SweeperDeposit"][] | null;
+            /** @description Cursor for the next page; empty when this page is the last */
+            nextPageToken?: string | null;
+        };
         ListFollowLeaderPositionsResponse: {
             positions?: components["schemas"]["LeadTraderOpenPosition"][] | null;
         };
@@ -7828,6 +8207,23 @@ export interface components {
             /** @description Time of the leaderboard snapshot these rows come from (RFC 3339) */
             asOf?: string | null;
         };
+        ListLiquidationEventsResponse: {
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             */
+            tradingPairId?: string | null;
+            /** @description Events in reverse chronological order (newest first). Each row contains only public event fields. */
+            events?: components["schemas"]["LiquidationEvent"][] | null;
+            /**
+             * Format: uint32
+             * @description Number of events requested for this page
+             * @example 50
+             */
+            pageSize?: number | null;
+            /** @description Opaque cursor for the next page; empty when the page is the end of the ordered result */
+            nextPageToken?: string | null;
+        };
         ListManagedMarketAssignmentsResponse: {
             /** @description Expected assignments, including phases currently unable to quote. */
             items?: components["schemas"]["ManagedMarketAssignment"][] | null;
@@ -10375,23 +10771,100 @@ export interface components {
              */
             minSweepRaw?: string | null;
         };
-        TpSlLeg: {
-            triggerPrice?: string | null;
-            orderType?: string | null;
-            limitPrice?: string | null;
-            quantity?: string | null;
-            timeInForce?: string | null;
-            /** Format: int32 */
-            slippageToleranceBps?: number | null;
-            expiresAt?: string | null;
+        /**
+         * @description One transfer into one of the caller's deposit addresses, and how far it has
+         *      got. Amounts are raw base units of the token on the source chain.
+         *      Timestamps are RFC3339 and record when the sweeper observed each step.
+         */
+        SweeperDeposit: {
+            /** @description The deposit transaction's hash, lowercase */
+            txHash?: string | null;
             /**
-             * @description Resolve the full live position size when triggered. Mutually exclusive
-             *      with quantity. For compatibility, omitting both quantity and this field
-             *      also means full-position close.
-             *
-             *      Attaching a full-close leg to a position SUPERSEDES that position's
-             *      previously active full-close legs of the same condition type: they are
-             *      cancelled in the same engine step that creates the replacement, so moving
+             * Format: int64
+             * @description EVM chain id the deposit was made on, as listed by `get_sweeper_chains`
+             * @example 8453
+             */
+            sourceChainId?: number | null;
+            /**
+             * Format: uint32
+             * @description The source chain's CCTP domain, once the deposit's CCTP burn is known; absent for hub deposits and before then
+             * @example 6
+             */
+            sourceDomain?: number | null;
+            /** @description The address the deposit is credited to (the caller's own), lowercase */
+            beneficiary?: string | null;
+            /** @description Client id of the application the deposit address was registered under */
+            clientId?: string | null;
+            /**
+             * @description The ledger the deposit address asks to be credited to
+             * @enum {string|null}
+             */
+            depositTarget?: "SPOT" | "MARGIN" | null;
+            /** @description The deposited token's address on the source chain, lowercase */
+            token?: string | null;
+            /**
+             * @description Amount deposited, raw base units of `token`
+             * @example 5000000
+             */
+            amountRaw?: string | null;
+            /**
+             * @description Amount credited to the exchange, once `DEPOSITED`. Absent when one CCTP burn carried several deposits (its fee cannot be split between them)
+             * @example 4999000
+             */
+            creditedAmountRaw?: string | null;
+            /**
+             * @description `amountRaw` minus `creditedAmountRaw` (Circle's fast-lane fee for a CCTP deposit, 0 on the hub); absent whenever `creditedAmountRaw` is
+             * @example 1000
+             */
+            feeChargedRaw?: string | null;
+            /**
+             * @description The CCTP lane the burn requested, once the burn is known; absent for hub deposits
+             * @enum {string|null}
+             */
+            transferType?: "FAST" | "STANDARD" | null;
+            /**
+             * @description Where the deposit is; see the operation description
+             * @example ATTESTING
+             * @enum {string|null}
+             */
+            status?: "RECEIVED" | "BURNED" | "ATTESTING" | "ATTESTED" | "SETTLING" | "DEPOSITED" | "FAILED" | null;
+            /**
+             * @description Why the deposit `FAILED`
+             * @enum {string|null}
+             */
+            failureReason?: "REFUNDED" | null;
+            /** @description The source-chain transaction that swept the deposit (the CCTP burn for a remote deposit), once swept */
+            sweepTx?: string | null;
+            /** @description The hub transaction that deposited the funds into the exchange, once `DEPOSITED` (the sweep itself for a hub deposit) */
+            settleTx?: string | null;
+            /** @description When Circle's attestation was first seen */
+            attestedAt?: string | null;
+            /** @description When the deposit was seen `DEPOSITED` */
+            settledAt?: string | null;
+            /** @description When the deposit was seen `FAILED` */
+            failedAt?: string | null;
+            /** @description When the sweeper indexed the deposit */
+            createdAt?: string | null;
+            /** @description When the sweeper last observed progress on the deposit */
+            updatedAt?: string | null;
+        };
+        TpSlLeg: {
+            triggerPrice?: string | null;
+            orderType?: string | null;
+            limitPrice?: string | null;
+            quantity?: string | null;
+            timeInForce?: string | null;
+            /** Format: int32 */
+            slippageToleranceBps?: number | null;
+            expiresAt?: string | null;
+            /**
+             * @description Resolve the full live position size when triggered. Mutually exclusive
+             *      with quantity. For compatibility, omitting both quantity and this field
+             *      also means full-position close.
+             *
+             *      Attaching a full-close leg to a position SUPERSEDES that position's
+             *      previously active full-close legs of the same condition type: they are
+             *      cancelled in the same engine step that creates the replacement, so moving
              *      a take-profit or stop-loss is one call with no window in which the
              *      position holds both levels or neither. Fixed-quantity legs never
              *      participate — laddered partial exits stack — and a superseded leg's
@@ -10437,6 +10910,28 @@ export interface components {
              */
             tradeId?: string | null;
         };
+        TradeFlowBucket: {
+            /**
+             * Format: int64
+             * @description UTC-aligned bucket start as Unix milliseconds
+             */
+            bucketStart?: number | null;
+            /** @description Executed quote notional where maker side was SELL, in quote-asset units */
+            takerBuyNotional?: string | null;
+            /** @description Executed quote notional where maker side was BUY, in quote-asset units */
+            takerSellNotional?: string | null;
+            /** @description Taker buy notional divided by taker sell notional, rounded to six decimal places; null when sell notional is zero */
+            buySellRatio?: string | null;
+            /** @description Taker buy notional minus taker sell notional, in quote-asset units */
+            netNotional?: string | null;
+            /** @description Cumulative net notional from the selected range start through this bucket, in quote-asset units */
+            cumulativeVolumeDelta?: string | null;
+            /**
+             * Format: int64
+             * @description Number of executed trades in this bucket
+             */
+            tradeCount?: number | null;
+        };
         TraderCodeResponse: {
             /**
              * @description Your TraderCode — your normalized wallet address (clients render it `Monaco - <address>`). Always present; the permanent reward identity and a public alias even when a custom handle is set.
@@ -11280,33 +11775,120 @@ export interface components {
             username?: string | null;
         };
         UserTrade: {
+            /**
+             * Format: uuid
+             * @description Trade UUID
+             * @example 123e4567-e89b-12d3-a456-426614174000
+             */
             tradeId?: string | null;
-            /** Format: uuid */
-            orderId?: string | null;
-            positionId?: string | null;
-            /** Format: uuid */
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             * @example 456e7890-e12b-12d3-a456-426614174000
+             */
             tradingPairId?: string | null;
-            side?: string | null;
+            /**
+             * @description Execution price
+             * @example 35000.00
+             */
             price?: string | null;
+            /**
+             * @description Traded quantity
+             * @example 0.5
+             */
             quantity?: string | null;
-            liquidityRole?: string | null;
             /**
-             * @description Total fee this user paid on the trade, in raw quote units: for a taker,
-             *      Monaco's taker fee plus the frontend's builder fee; for a maker, the maker
-             *      fee (negative for a rebate) plus the frontend's maker add-on. Equals
-             *      `monaco_fee + builder_fee`.
+             * @description Quote volume (price * quantity)
+             * @example 17500.00
+             */
+            quoteVolume?: string | null;
+            /**
+             * @description User's side: Buy or Sell
+             * @example Buy
+             */
+            side?: string | null;
+            /**
+             * @description Total fee paid by this user for this trade. For a taker this is Monaco's taker fee plus the frontend's builder fee; for a maker it is the maker fee (negative for a rebate) plus the frontend's maker add-on. Equals `monacoFee + builderFee`.
+             * @example 0.875
              */
             fee?: string | null;
-            realizedPnl?: string | null;
-            timestamp?: string | null;
-            /** @description Monaco's component of `fee`, in raw quote units. */
+            /**
+             * @description Token address of the fee
+             * @example 0x6a86da986797d59a839d136db490292cd560c131
+             */
+            feeToken?: string | null;
+            /**
+             * @description Trade execution timestamp (RFC3339 with +00:00 offset)
+             * @example 2023-11-13T10:30:00+00:00
+             */
+            executedAt?: string | null;
+            /**
+             * @description Trading mode: SPOT or MARGIN
+             * @example SPOT
+             */
+            tradingMode?: string | null;
+            /**
+             * Format: uuid
+             * @description Maker order UUID
+             * @example 123e4567-e89b-12d3-a456-426614174000
+             */
+            makerOrderId?: string | null;
+            /**
+             * Format: uuid
+             * @description Taker order UUID
+             * @example 456e7890-e12b-12d3-a456-426614174000
+             */
+            takerOrderId?: string | null;
+            /**
+             * @description Traded quantity in smallest base-token unit
+             * @example 500000000000000000
+             */
+            quantityRaw?: string | null;
+            /**
+             * @description Quote volume in smallest quote-token unit
+             * @example 17500000000
+             */
+            quoteVolumeRaw?: string | null;
+            /**
+             * @description Total fee (`fee`) in smallest quote-token unit. Equals `monacoFeeRaw + builderFeeRaw`.
+             * @example 875000
+             */
+            feeRaw?: string | null;
+            /**
+             * @description Settlement status: PENDING, SETTLED, or FAILED
+             * @example SETTLED
+             */
+            settlementStatus?: string | null;
+            /**
+             * @description On-chain settlement transaction hash
+             * @example 0xabc123
+             */
+            settlementTxHash?: string | null;
+            /**
+             * @description Monaco's component of `fee`
+             * @example 0.875
+             */
             monacoFee?: string | null;
             /**
-             * @description The frontend's builder fee component of `fee`, in raw quote units: for a
-             *      taker, the builder fee; for a maker, the maker add-on, charged at the rate
-             *      the order stored when it was placed. "0" when the frontend charges none.
+             * @description Monaco's component of `feeRaw`, in smallest quote-token unit
+             * @example 875000
+             */
+            monacoFeeRaw?: string | null;
+            /**
+             * @description The frontend's builder fee component of `fee`: for a taker, the builder fee its frontend charged; for a maker, the maker add-on its frontend charged at the rate the order stored when it was placed. "0" when the frontend charges none.
+             * @example 0
              */
             builderFee?: string | null;
+            /**
+             * @description The frontend's builder fee component of `feeRaw`, in smallest quote-token unit
+             * @example 0
+             */
+            builderFeeRaw?: string | null;
+            /**
+             * @description This user's role in the fill: MAKER or TAKER. A self-trade reads as MAKER.
+             * @example TAKER
+             */
+            liquidityRole?: string | null;
         };
         VerifyRequest: {
             /**
@@ -12560,6 +13142,21 @@ export interface operations {
                  *      that produced the token.
                  */
                 pageToken?: string;
+                /**
+                 * @description Optional margin account UUID filter: only trades where this user's side of
+                 *      the fill was placed from this margin account. A self-trade is read as its
+                 *      maker side, so it matches through its maker order's account. Like
+                 *      `trading_pair_id`, a filtered response carries no `total`, and the filter
+                 *      must match the request that produced a `page_token`.
+                 */
+                marginAccountId?: string;
+                /**
+                 * @description Optional order UUID filter: only trades where this user's side of the
+                 *      fill was placed by this order. A self-trade is read as its maker side, so
+                 *      it matches its maker order only. A filtered response carries no `total`,
+                 *      and the filter must match the request that produced a `page_token`.
+                 */
+                orderId?: string;
             };
             header?: never;
             path?: never;
@@ -16420,6 +17017,112 @@ export interface operations {
             };
         };
     };
+    list_liquidation_events: {
+        parameters: {
+            query?: {
+                /** @description Start time as Unix timestamp (milliseconds) */
+                startTime?: number;
+                /** @description End time as Unix timestamp (milliseconds) */
+                endTime?: number;
+                /** @description Events per page (max 1000) */
+                pageSize?: number;
+                /**
+                 * @description Opaque keyset cursor from the previous response. The token is bound to
+                 *      this pair and the requested time filters.
+                 */
+                pageToken?: string;
+            };
+            header?: never;
+            path: {
+                /** @example 893d2add-2f36-4ee7-b660-893d2add2f36 */
+                tradingPairId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListLiquidationEventsResponse"];
+                };
+            };
+            /** @description Invalid liquidation-event filter or page token */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Trading pair not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_liquidation_metrics: {
+        parameters: {
+            query?: {
+                interval?: string;
+                /** @description Start time as Unix timestamp (milliseconds) */
+                startTime?: number;
+                /** @description End time as Unix timestamp (milliseconds) */
+                endTime?: number;
+            };
+            header?: never;
+            path: {
+                /** @example 893d2add-2f36-4ee7-b660-893d2add2f36 */
+                tradingPairId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetLiquidationMetricsResponse"];
+                };
+            };
+            /** @description Invalid interval or out-of-bounds time range */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Trading pair not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     get_mark_price: {
         parameters: {
             query?: never;
@@ -16563,6 +17266,101 @@ export interface operations {
             };
         };
     };
+    get_trade_flow: {
+        parameters: {
+            query: {
+                /** @description UTC-aligned bucket interval */
+                interval: "1m" | "5m" | "1h";
+                /** @description Unix timestamp in milliseconds; range is at most seven days */
+                startTime: number;
+                /** @description Unix timestamp in milliseconds; range is at most seven days */
+                endTime: number;
+            };
+            header?: never;
+            path: {
+                /** @example 893d2add-2f36-4ee7-b660-893d2add2f36 */
+                tradingPairId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetTradeFlowResponse"];
+                };
+            };
+            /** @description Invalid or out-of-bounds time range */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Trading pair not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_trader_metrics: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @example 893d2add-2f36-4ee7-b660-893d2add2f36 */
+                tradingPairId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetTraderMetricsResponse"];
+                };
+            };
+            /** @description Invalid market request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Trading pair not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     get_screener: {
         parameters: {
             query?: {
@@ -17351,7 +18149,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Duplicate clientTwapId for this user and application */
+            /** @description Duplicate clientTwapId for this user and application: a parent with that key is live or ended within the reservation lifetime (30 days by default) */
             409: {
                 headers: {
                     [name: string]: unknown;
@@ -18176,6 +18974,133 @@ export interface operations {
             };
         };
     };
+    list_sweeper_deposits: {
+        parameters: {
+            query?: {
+                /** @description Items per page (max 100) */
+                pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start the walk from the newest deposit.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `next_page_token`; results resume immediately after that position.
+                 *
+                 *      The walk seeks on `(created_at, id)` descending over the caller's
+                 *      inflows, served by `idx_sweeper_transfers_user_inflows`. `created_at` is
+                 *      when the sweeper recorded the deposit and `id` an insertion-ordered
+                 *      identity, so the key is total and immutable.
+                 */
+                pageToken?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListDepositsResponse"];
+                };
+            };
+            /** @description pageSize out of range, or a pageToken that is malformed or minted by another listing */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Read rate limit exceeded — every authenticated read draws one request from the account's read budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Deposit status not available in this environment, or the read took too long; safe to retry */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_sweeper_deposit_status: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                txHash: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetDepositStatusResponse"];
+                };
+            };
+            /** @description txHash is not a 0x-prefixed 32-byte hex hash */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Read rate limit exceeded — every authenticated read draws one request from the account's read budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Deposit status not available in this environment, or the read took too long; safe to retry */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     register_deposit_address: {
         parameters: {
             query?: never;