@0xmonaco/types 1.0.74 → 1.0.76

package/dist/wire/schema.d.ts

@@ -444,8 +444,8 @@ export interface paths {
          * List application balances
          * @description List application balances.
          *
-         *      Returns a paginated list of all user balances for this application.
-         *      Requires backend authentication via secret key.
+         *      Returns a paginated list of the balances of the application's users.
+         *      Public: the application is selected by `client_id`.
          */
         get: operations["list_application_balances"];
         put?: never;
@@ -490,9 +490,9 @@ export interface paths {
          * List application movements
          * @description List application movements.
          *
-         *      Returns a paginated list of all ledger movements (deposits, withdrawals,
-         *      trades, etc.) for this application. Requires backend authentication via
-         *      secret key.
+         *      Returns a paginated list of the ledger movements (deposits, withdrawals,
+         *      trades, etc.) of the application's users. Public: the application is
+         *      selected by `client_id`.
          */
         get: operations["list_application_movements"];
         put?: never;
@@ -514,8 +514,8 @@ export interface paths {
          * List application orders
          * @description List application orders.
          *
-         *      Returns a paginated list of all orders for this application. Requires
-         *      backend authentication via secret key.
+         *      Returns a paginated list of all orders placed by the application's users.
+         *      Public: the application is selected by `client_id`.
          */
         get: operations["list_application_orders"];
         put?: never;
@@ -538,8 +538,8 @@ export interface paths {
          * @description Get application stats.
          *
          *      Returns aggregate volume and fee stats for this application. Stats are
-         *      scoped to trades where the application's users were the taker. Requires
-         *      backend authentication via secret key.
+         *      scoped to trades where the application's users were the taker. Public:
+         *      the application is selected by `client_id`.
          */
         get: operations["get_application_stats"];
         put?: never;
@@ -561,8 +561,8 @@ export interface paths {
          * List application users
          * @description List application users.
          *
-         *      Returns a paginated list of all users for this application. Requires
-         *      backend authentication via secret key.
+         *      Returns a paginated list of the application's users. Public: the
+         *      application is selected by `client_id`.
          */
         get: operations["list_application_users"];
         put?: never;
@@ -732,9 +732,10 @@ export interface paths {
          *      application's behalf do not count. Setting the fee it already has is a
          *      no-op that succeeds and does not use up a change.
          *
-         *      The fee can be set while builder fees are switched off
-         *      (`builderFeeEnabled` false): it is stored and nothing is charged until they
-         *      are switched on. A newly stored fee reaches order requests within a few
+         *      The fee can be set while the revenue share or builder fees are switched
+         *      on, and is refused (**HTTP 403** / **PERMISSION_DENIED**) while both are
+         *      off. With builder fees off (`builderFeeEnabled` false) it is stored and
+         *      nothing is charged until they are switched on. A newly stored fee reaches order requests within a few
          *      seconds. Sequencer ordering is authoritative for matching-engine policy and
          *      enrollment state: an order processed before one of those sequenced changes
          *      uses the earlier state, and a later order uses the new state.
@@ -790,8 +791,7 @@ export interface paths {
          *
          *      The application is taken from the authenticated session; there is no
          *      application id in the request. The caller must be the application's
-         *      configured payout wallet. This method is gated by `buildercodes_enabled`
-         *      like the rest of the service.
+         *      configured payout wallet.
          */
         get: operations["get_buildercodes_config"];
         put?: never;
@@ -912,13 +912,13 @@ export interface paths {
          *
          *      Delegated-agent sessions are refused: a delegated grant conveys only
          *      order-management authority, and this claim converts reserved balance into a
-         *      tradeable one. The refusal happens before the feature check, so a delegated
-         *      caller is refused whether or not BuilderCodes is enabled.
+         *      tradeable one. No program switch gates the claim: a balance already
+         *      credited stays claimable whether or not the revenue share is on.
          *
          *      Transport contracts differ, and this comment is emitted into the generated
          *      gRPC SDK where HTTP statuses do not exist. An insufficient payout balance
          *      is **HTTP 409** on REST and **FAILED_PRECONDITION** on gRPC; a refused
-         *      caller (delegated session, or BuilderCodes disabled) is **HTTP 403** on
+         *      caller (delegated session) is **HTTP 403** on
          *      REST and **PERMISSION_DENIED** on gRPC.
          *
          *      A claim can also fail as **HTTP 503** / **UNAVAILABLE** when the matching
@@ -1963,6 +1963,51 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/margin/sub-accounts/{marginAccountId}/collateral/transfer-in": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * @description Move collateral from the caller's default margin account to one of their
+         *      sub-accounts, in one sequenced step. The same move as `TransferCollateral`
+         *      from the default account to the sub-account. The path names an open
+         *      sub-account of the caller; the default margin account itself is refused
+         *      (fund it with the parent-margin-account routes).
+         */
+        post: operations["transfer_collateral_to_sub_account"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/margin/sub-accounts/{marginAccountId}/collateral/transfer-out": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * @description Move collateral from one of the caller's sub-accounts back to their
+         *      default margin account, in one sequenced step. The mirror of
+         *      `TransferCollateralToSubAccount`; the amount must fit the sub-account's
+         *      free collateral.
+         */
+        post: operations["transfer_collateral_from_sub_account"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/market/funding/history": {
         parameters: {
             query?: never;
@@ -2758,8 +2803,9 @@ export interface paths {
          * @description Read your own referral position (self-scoped).
          *
          *      Return the authenticated caller's referral position: their referral chain
-         *      upward (L1, L2 and L3 — who referred them, who referred that wallet, and so
-         *      on), the total rewards they have earned, and their most recent reward rows.
+         *      upward (L1, L2 and onward — who referred them, who referred that wallet, and
+         *      so on, as many levels as PitPass currently rewards), the total rewards they
+         *      have earned, and their most recent reward rows.
          *      Self-scoped — identity comes only from the session, never a path id,
          *      so a caller can only ever read their own chain. Every other user is
          *      identified by their public wallet address, never an internal id. An empty
@@ -2785,10 +2831,12 @@ export interface paths {
          * Get your referral downline and earnings
          * @description Read your own downline earnings (self-scoped).
          *
-         *      Return who the authenticated caller earns from and how much: an
-         *      earnings-by-source breakdown aggregated from the caller's reward rows across
-         *      all three reward levels (L1/L2/L3), their L1 direct-referee roster (including
-         *      referees who have not traded yet), and a per-level earnings summary.
+         *      Return who the authenticated caller earns from and how much: one page of
+         *      the earnings-by-source breakdown across every reward level, their L1
+         *      direct-referee roster (including referees who have not traded yet), and a
+         *      per-level earnings summary that always covers every level and source,
+         *      whatever page is requested. `earnings_by_source` is paged (`page_size`,
+         *      `page_token`); a request without them gets the first page, not every row.
          *      Self-scoped — identity comes only from the session, never a path id. Every
          *      source and referee is identified by their public wallet address, never an
          *      internal id.
@@ -2814,16 +2862,16 @@ export interface paths {
          * @description Read one level of your own referral tree (self-scoped).
          *
          *      Return the wallets directly referred by `parent` — the authenticated caller
-         *      when `parent` is omitted, otherwise one of the caller's own L1 or L2
-         *      referees — one page at a time, newest first. Each node carries its level
+         *      when `parent` is omitted, otherwise one of the caller's own referees above
+         *      the deepest rewarded level — one page at a time, newest first. Each node carries its level
          *      relative to the caller, its parent, how many wallets it has referred (so the
          *      client knows whether it can be expanded), and what the caller has earned
          *      from that wallet's own trades. Expanding a node is another call with
-         *      `parent` set to that node's wallet; the tree stops at L3, the deepest level
-         *      that pays referral rewards.
+         *      `parent` set to that node's wallet; the tree stops at the deepest level that
+         *      pays referral rewards, which an admin configures (at most 10).
          *
          *      Self-scoped — identity comes only from the session. A `parent` that is not
-         *      the caller or inside the caller's own L1/L2 downline returns 404, the same
+         *      the caller or a referee the caller can expand returns 404, the same
          *      as a wallet that does not exist, so the endpoint cannot be used to read
          *      anyone else's tree. Every node is identified by its public wallet address,
          *      never an internal id.
@@ -3442,28 +3490,16 @@ export interface components {
              * @example master
              */
             accountType?: string | null;
-            /**
-             * @description Whether the user is allowed to withdraw
-             * @example true
-             */
-            canWithdraw?: boolean | null;
             /**
              * @description Account creation timestamp (ISO 8601)
              * @example 2023-11-13T10:30:00Z
              */
             createdAt?: string | null;
-            /** @description Email address */
-            email?: string | null;
             /**
              * @description Whether the user account is active
              * @example true
              */
             isActive?: boolean | null;
-            /**
-             * @description Whether the user is banned
-             * @example false
-             */
-            isBanned?: boolean | null;
             /**
              * Format: uuid
              * @description Master account ID (for sub-accounts)
@@ -3898,7 +3934,7 @@ export interface components {
              */
             strategyKey?: string | null;
             /**
-             * @description Risk bucket mode for margin orders. Defaults to ISOLATED. Values: ISOLATED, CROSS.
+             * @description Risk bucket mode for margin orders. Defaults to ISOLATED. Values: ISOLATED, CROSS. On an isolated-only market (TradingPairData.isolated_only) a CROSS order that is not reduce-only is rejected with HTTP 400 / gRPC INVALID_ARGUMENT carrying the structured error code CROSS_MARGIN_NOT_ALLOWED.
              * @example CROSS
              * @enum {string|null}
              */
@@ -4699,7 +4735,7 @@ export interface components {
              */
             strategyKey?: string | null;
             /**
-             * @description Risk bucket mode for margin orders. Defaults to ISOLATED. Values: ISOLATED, CROSS.
+             * @description Risk bucket mode for margin orders. Defaults to ISOLATED. Values: ISOLATED, CROSS. On an isolated-only market (TradingPairData.isolated_only) a CROSS order that is not reduce-only is rejected with HTTP 400 / gRPC INVALID_ARGUMENT carrying the structured error code CROSS_MARGIN_NOT_ALLOWED.
              * @example CROSS
              * @enum {string|null}
              */
@@ -4865,7 +4901,7 @@ export interface components {
              */
             riskBucketId?: string | null;
             /**
-             * @description Risk bucket mode for margin TWAP orders. Defaults to ISOLATED. Values: ISOLATED, CROSS.
+             * @description Risk bucket mode for margin TWAP orders. Defaults to ISOLATED. Values: ISOLATED, CROSS. On an isolated-only market (TradingPairData.isolated_only) a CROSS order that is not reduce-only is rejected with HTTP 400 / gRPC INVALID_ARGUMENT carrying the structured error code CROSS_MARGIN_NOT_ALLOWED.
              * @example CROSS
              * @enum {string|null}
              */
@@ -5429,12 +5465,6 @@ export interface components {
              * @example 5
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -5447,6 +5477,12 @@ export interface components {
              * @example 1
              */
             totalPages?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page. The whole set is already in memory, so over-fetching is free and an
+             *      empty token is the definitive end of the walk.
+             */
+            nextPageToken?: string | null;
         };
         GetBuildercodePayoutSummaryResponse: {
             /**
@@ -5481,7 +5517,7 @@ export interface components {
              * @example 0x0000000000000000000000000000000000000001
              */
             payoutAddress?: string | null;
-            /** @description Current BuilderCodes feature-flag state. Successful responses are true because this endpoint is gated by the flag. */
+            /** @description Whether the BuilderCodes revenue share is switched on. While false no new share accrues; balances already credited stay readable and claimable. */
             buildercodesEnabled?: boolean | null;
             /**
              * Format: uint32
@@ -5632,16 +5668,15 @@ export interface components {
         };
         GetMarginAccountMovementsResponse: {
             movements?: components["schemas"]["MarginAccountMovement"][] | null;
-            /**
-             * Format: uint32
-             * @description Matching movements. 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 movements than the listing can page through reads the cap, not its lifetime total.
-             * @example 150
-             */
-            total?: number | null;
-            /** Format: uint32 */
-            page?: number | null;
             /** Format: uint32 */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one SQL statement with one global ORDER BY, so a
+             *      page shorter than `pageSize` proves the walk is exhausted and this is
+             *      empty. A non-empty token always has at least one further row behind it.
+             */
+            nextPageToken?: string | null;
         };
         GetMarginAccountPnlResponse: {
             marginAccountId?: string | null;
@@ -5683,6 +5718,9 @@ export interface components {
              *      bucket cannot be released at all, and the parent margin account is
              *      charged at most its allocation, the loss past it being the insurance
              *      fund's.
+             *
+             *      Printed truncated toward zero at the quote asset's precision, so the
+             *      printed amount itself is always accepted.
              */
             withdrawableCollateral?: string | null;
             totalPositionNotional?: string | null;
@@ -5854,16 +5892,10 @@ export interface components {
             movements?: components["schemas"]["LedgerMovement"][] | null;
             /**
              * Format: uint32
-             * @description Matching movements. Exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so a user with more matching movements than the listing can page through reads the cap, not their lifetime total.
+             * @description Number of movements matching the filter, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 150
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -5872,15 +5904,28 @@ export interface components {
             pageSize?: number | null;
             /**
              * Format: uint32
-             * @description Number of pages at the requested page size. Exact up to 10,000 and saturates there, the last page this listing can reach.
+             * @description Number of pages at this pageSize, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 8
              */
             totalPages?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page. Each arm of the union is cut at the same over-fetched depth and the
+             *      outer query orders the merged rows, so a page shorter than `pageSize`
+             *      means both arms are exhausted and this is empty — a non-empty token always
+             *      has at least one further row behind it.
+             */
+            nextPageToken?: string | null;
+            /**
+             * @description True when more than the server ceiling of movements matched, so the count stopped at the ceiling and total/totalPages are a lower bound. False when total is exact, including exactly the ceiling.
+             * @example false
+             */
+            totalCapped?: boolean | null;
         };
         GetMyFeeTierResponse: {
             /**
              * Format: int32
-             * @description Caller's resolved tier (1–6) from their wallet's stored weighted 14-day volume
+             * @description Caller's resolved tier (1–6) from the higher of their wallet's weighted 14-day volume and any volume floor set on the wallet. A floor that is set or changed counts once it applies to the wallet's fills, usually within a minute, and likewise for an account the wallet opens in a new application; a removed or expired floor stops counting at once
              * @example 2
              */
             currentTierLevel?: number | null;
@@ -5900,7 +5945,7 @@ export interface components {
              */
             perpVolume14d?: string | null;
             /**
-             * @description Additional weighted volume needed to reach the next tier; omitted at tier 6
+             * @description Additional weighted volume needed to reach the next tier, counted from the volume the current tier resolved from; omitted at tier 6
              * @example 17500000
              */
             volumeToNextTier?: string | null;
@@ -5914,12 +5959,14 @@ export interface components {
             feeSchedule?: components["schemas"]["FeeTierScheduleRow"][] | null;
         };
         GetMyReferralDownlineResponse: {
-            /** @description One row per (source trader, level, token) the caller earns from, across all three reward levels. Comes straight from the caller's reward rows — no tree walk. */
+            /** @description One page of rows, one per (source account, level, token) the caller earns from, across every reward level, ordered by each source account's own total, largest first. A wallet that traded through several applications has one account per application: its rows within a page are merged into one row at the position of its first (largest) part, so a merged row can sit below a smaller one, and the wallet can appear again on a later page. Paged by `pageSize` / `pageToken`; follow `nextPageToken` for the rest. Comes from the caller's maintained reward totals — no tree walk. */
             earningsBySource?: components["schemas"]["ReferralEarningsSource"][] | null;
-            /** @description The caller's direct (L1) referees, newest first, including referees who have not traded yet (0 earned). Bounded to the most recent 500 EFFECTIVE referees (after per-wallet dedupe and the winning-edge filter). The earnings views (`earnings_by_source` and the summary) are unbounded and count every level, so a caller past the roster cap still sees their full earnings; only this roster listing is capped. */
+            /** @description The caller's direct (L1) referees, newest first, including referees who have not traded yet (0 earned). Bounded to the most recent 500 EFFECTIVE referees (after per-wallet dedupe and the winning-edge filter). The summary counts every level and source and `earnings_by_source` pages through every row, so a caller past the roster cap still sees their full earnings; only this roster listing is capped. */
             directReferees?: components["schemas"]["ReferralDirectReferee"][] | null;
-            /** @description Total earned broken down by level (L1/L2/L3). */
+            /** @description Total earned broken down by level. Covers every level and source regardless of the `earnings_by_source` page. */
             summary?: components["schemas"]["ReferralEarningsSummary"] | null;
+            /** @description Cursor for the next `earningsBySource` page; empty when there are no more rows. */
+            nextPageToken?: string | null;
         };
         GetMyReferralPositionResponse: {
             /**
@@ -5939,7 +5986,7 @@ export interface components {
             referrerDisplay?: string | null;
             /** @description The caller's most recent reward rows, newest first. Bounded server-side — not the full history. */
             rewards?: components["schemas"]["ReferralRewardEntry"][] | null;
-            /** @description The caller's referral chain upward, nearest first: L1 (who referred the caller), then L2 (who referred them), then L3. At most three entries; shorter when the chain ends, empty when the caller was not referred. These are the wallets the caller's own trades pay referral rewards to. */
+            /** @description The caller's referral chain upward, nearest first: L1 (who referred the caller), then L2 (who referred them), and so on. At most as many entries as PitPass currently rewards levels (at most 10); shorter when the chain ends, empty when the caller was not referred. These are the wallets the caller's own trades pay referral rewards to. */
             upline?: components["schemas"]["ReferralUplineEntry"][] | null;
         };
         GetMyReferralTreeResponse: {
@@ -5947,7 +5994,7 @@ export interface components {
             parent?: string | null;
             /**
              * Format: int32
-             * @description Depth of `parent` below the caller: 0 for the caller, 1 or 2 for a referee being expanded. Every node is one level deeper.
+             * @description Depth of `parent` below the caller: 0 for the caller, otherwise the level of the referee being expanded. Every node is one level deeper.
              */
             parentLevel?: number | null;
             /** @description The wallets `parent` referred, newest first. A wallet that signed up under several referrers (one per app) appears only under the referrer the reward engine pays. */
@@ -5998,7 +6045,7 @@ export interface components {
              */
             tradingPairId?: string | null;
             /**
-             * @description What kind of order this row is: LIMIT or MARKET for a book order, TWAP for a TWAP parent, CONDITIONAL for a price-triggered order. TWAP and CONDITIONAL appear only in responses — they name a row's kind and cannot be placed through the create-order request, which still takes LIMIT, MARKET or IOC. A row of either kind carries its kind-specific fields in `twap` or `conditional`; the fields shared by every kind (id, side, quantity, status, timestamps) are populated in place as usual.
+             * @description Order type: LIMIT or MARKET
              * @example LIMIT
              */
             orderType?: string | null;
@@ -6008,7 +6055,7 @@ export interface components {
              */
             side?: string | null;
             /**
-             * @description Limit price (null for market orders). For a TWAP parent this is its optional parent-level limit price, and for a conditional order the limit price its triggered order will carry (null when it triggers as a market order).
+             * @description Limit price (null for market orders)
              * @example 35000.00
              */
             price?: string | null;
@@ -6191,7 +6238,7 @@ export interface components {
              */
             batchId?: string | null;
             /**
-             * @description Stable terminal cause for a cancelled order: USER_REQUESTED, REPLACED, LIQUIDATION, INSUFFICIENT_MARGIN, REDUCE_ONLY_EXHAUSTED, POSITION_CLOSED, OCO_SIBLING_TRIGGERED, SELF_TRADE_PREVENTION, AUTO_DELEVERAGING, or SYSTEM. AUTO_DELEVERAGING means auto-deleveraging closed the position your risk bucket held and this resting order was cancelled with it; you were deleveraged as a counterparty, not liquidated.
+             * @description Stable terminal cause for a cancelled order: USER_REQUESTED, REPLACED, LIQUIDATION, INSUFFICIENT_MARGIN, REDUCE_ONLY_EXHAUSTED, POSITION_CLOSED, OCO_SIBLING_TRIGGERED, SELF_TRADE_PREVENTION, AUTO_DELEVERAGING, PRICE_BAND, SLIPPAGE_TOLERANCE, or SYSTEM. AUTO_DELEVERAGING means auto-deleveraging closed the position your risk bucket held and this resting order was cancelled with it; you were deleveraged as a counterparty, not liquidated. PRICE_BAND means the exchange's protective price band stopped the order and its remainder was cancelled; SLIPPAGE_TOLERANCE means your own slippageToleranceBps did.
              * @example REDUCE_ONLY_EXHAUSTED
              */
             terminalReason?: string | null;
@@ -6200,10 +6247,6 @@ export interface components {
              * @example false
              */
             postOnly?: boolean | null;
-            /** @description Present only when orderType is TWAP: the full TWAP parent, identical to what GET /api/v1/orders/twap/{twapOrderId} returns — schedule, slice counters, progress, and terminal reason. The row's shared fields mirror it: quantity is the parent's total quantity, filledQuantity its executed quantity, and status maps its state onto the order statuses. */
-            twap?: components["schemas"]["TwapOrder"] | null;
-            /** @description Present only when orderType is CONDITIONAL: the full conditional order, identical to what the conditional-order endpoints return — trigger price and direction, condition type, linked group, and the order it triggers into. The row's shared fields mirror it, with status mapping its state onto the order statuses. */
-            conditional?: components["schemas"]["ConditionalOrder"] | 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.
@@ -6645,6 +6688,11 @@ export interface components {
              * @example 918342
              */
             version?: number | null;
+            /**
+             * @description RFC 3339 instant at which this position opened. Same contract as
+             *      `Position.opened_at` above.
+             */
+            openedAt?: string | null;
         };
         GetPositionRiskResponse: {
             positionId?: string | null;
@@ -6848,18 +6896,36 @@ export interface components {
         /** @description Recent trades for a trading pair. */
         GetTradesResponse: {
             trades?: components["schemas"]["PublicTrade"][] | null;
-            /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Maximum number of trades returned
              * @example 25
              */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, under **proven** semantics: the read over-fetches
+             *      one row past `page_size`, so an empty token means the walk is finished and
+             *      a non-empty token means a further trade was actually seen. Unlike
+             *      `ListUserTradesResponse.next_page_token` (AIP-158 "maybe more"), a client
+             *      can stop here on the empty token without a confirming extra request — this
+             *      listing reads one table, so there is no hot/archive interleave that could
+             *      hide rows behind a short page.
+             *
+             *      That one table is the hot `trades` table, so a walk reaches the end of the
+             *      archiver's retention window rather than the end of the pair's history. This
+             *      is the endpoint's long-standing scope, unchanged by the cursor.
+             *
+             *      There is no public walk over a pair's ARCHIVED history, and this endpoint is
+             *      not a partial one — do not point market-data consumers at the user trade
+             *      listings to continue it. `GetUserTrades` / `ListUserTrades` do merge the
+             *      archive, but they are authenticated and user-scoped (`auth.user_id` is the
+             *      read's first mandatory filter), so they return only trades where the caller
+             *      was maker or taker. Following them to extend a public pair tape would
+             *      silently drop every fill between two other parties. An individual archived
+             *      trade does stay publicly reachable by id: `GetTradeById` falls back to the
+             *      archive table on a hot miss.
+             */
+            nextPageToken?: string | null;
         };
         /** @description Single trading pair details. */
         GetTradingPairResponse: {
@@ -7250,29 +7316,50 @@ export interface components {
              */
             balanceId?: string | null;
         };
+        /** @description What the caller has earned at one referral level. */
+        LevelEarnings: {
+            /**
+             * Format: int32
+             * @description Referral level: 1 for direct referees, 2 for their referees, and so on (at most 10).
+             * @example 1
+             */
+            level?: number | null;
+            /**
+             * @description All-time credited earnings at this level, in the reward token's RAW atomic units.
+             * @example 900000
+             */
+            earned?: string | null;
+        };
         ListAllFundingHistoryResponse: {
             records?: components["schemas"]["FundingRecord"][] | null;
-            /** Format: uint32 */
+            /**
+             * Format: uint32
+             * @description Settlements matching the filter, bounded by the server count ceiling — see
+             *      `totalCapped`. A lower bound when `totalCapped` is true.
+             */
             total?: number | null;
             /** Format: uint32 */
-            page?: number | null;
-            /** Format: uint32 */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `pageSize` proves the walk is exhausted and this is empty.
+             */
+            nextPageToken?: string | null;
+            /**
+             * @description True when MORE than the server ceiling matched, so the count stopped at
+             *      the ceiling and `total` is a lower bound.
+             */
+            totalCapped?: boolean | null;
         };
         ListAppBalancesResponse: {
             balances?: components["schemas"]["ApplicationBalance"][] | null;
             /**
              * Format: uint32
-             * @description Total matching balances
+             * @description Number of balances matching the filter, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 50
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -7281,25 +7368,24 @@ export interface components {
             pageSize?: number | null;
             /**
              * Format: uint32
-             * @description Total number of pages
+             * @description Number of pages at this pageSize, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 3
              */
             totalPages?: number | null;
-        };
-        ListAppMovementsResponse: {
-            movements?: components["schemas"]["ApplicationMovement"][] | null;
             /**
-             * Format: uint32
-             * @description Matching movements. Exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so an application with more matching movements than the listing can page through reads the cap, not its lifetime total.
-             * @example 150
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `pageSize` proves the walk is exhausted and this is empty.
              */
-            total?: number | null;
+            nextPageToken?: string | null;
             /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
+             * @description True when more than the server ceiling of balances matched, so the count stopped at the ceiling and total/totalPages are a lower bound.
+             * @example false
              */
-            page?: number | null;
+            totalCapped?: boolean | null;
+        };
+        ListAppMovementsResponse: {
+            movements?: components["schemas"]["ApplicationMovement"][] | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -7307,26 +7393,14 @@ export interface components {
              */
             pageSize?: number | null;
             /**
-             * Format: uint32
-             * @description Number of pages at the requested page size. Exact up to 10,000 and saturates there, the last page this listing can reach.
-             * @example 8
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `pageSize` proves the walk is exhausted and this is empty.
              */
-            totalPages?: number | null;
+            nextPageToken?: string | null;
         };
         ListAppOrdersResponse: {
             orders?: components["schemas"]["ApplicationOrder"][] | null;
-            /**
-             * Format: uint32
-             * @description Matching orders. Exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so an application with more matching orders than the listing can page through reads the cap, not its lifetime total.
-             * @example 150
-             */
-            total?: number | null;
-            /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -7334,26 +7408,20 @@ export interface components {
              */
             pageSize?: number | null;
             /**
-             * Format: uint32
-             * @description Number of pages at the requested page size. Exact up to 10,000 and saturates there, the last page this listing can reach.
-             * @example 8
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `pageSize` proves the walk is exhausted and this is empty.
              */
-            totalPages?: number | null;
+            nextPageToken?: string | null;
         };
         ListAppUsersResponse: {
             users?: components["schemas"]["AppUser"][] | null;
             /**
              * Format: uint32
-             * @description Total number of users
+             * @description Number of users matching the filter, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 50
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -7362,10 +7430,21 @@ export interface components {
             pageSize?: number | null;
             /**
              * Format: uint32
-             * @description Total number of pages
+             * @description Number of pages at this pageSize, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 3
              */
             totalPages?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `pageSize` proves the walk is exhausted and this is empty.
+             */
+            nextPageToken?: string | null;
+            /**
+             * @description True when more than the server ceiling of users matched, so the count stopped at the ceiling and total/totalPages are a lower bound.
+             * @example false
+             */
+            totalCapped?: boolean | null;
         };
         ListBuilderFeeChangesResponse: {
             /** @description Builder-fee changes, newest first. */
@@ -7381,11 +7460,6 @@ export interface components {
              * @description Total payout rows for this application.
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @description Current page number.
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page.
@@ -7396,6 +7470,12 @@ export interface components {
              * @description Total number of pages.
              */
             totalPages?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `page_size` proves the walk is exhausted and this is empty.
+             */
+            nextPageToken?: string | null;
         };
         ListConditionalOrdersResponse: {
             orders?: components["schemas"]["ConditionalOrder"][] | null;
@@ -7432,27 +7512,34 @@ export interface components {
         };
         ListFundingHistoryResponse: {
             records?: components["schemas"]["FundingRecord"][] | null;
-            /** Format: uint32 */
+            /**
+             * Format: uint32
+             * @description Settlements matching the filter, bounded by the server count ceiling — see
+             *      `totalCapped`. A lower bound when `totalCapped` is true.
+             */
             total?: number | null;
             /** Format: uint32 */
-            page?: number | null;
-            /** Format: uint32 */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `pageSize` proves the walk is exhausted and this is empty.
+             */
+            nextPageToken?: string | null;
+            /**
+             * @description True when MORE than the server ceiling matched, so the count stopped at
+             *      the ceiling and `total` is a lower bound.
+             */
+            totalCapped?: boolean | null;
         };
         ListFundingPaymentsResponse: {
             records?: components["schemas"]["FundingPaymentRecord"][] | null;
             /**
              * Format: uint32
-             * @description Matching funding payment records. Exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so a user with more matching payments than the listing can page through reads the cap, not their lifetime total.
+             * @description Number of funding payments matching the filter, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 2
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -7461,10 +7548,21 @@ export interface components {
             pageSize?: number | null;
             /**
              * Format: uint32
-             * @description Number of pages at the requested page size. Exact up to 10,000 and saturates there, the last page this listing can reach.
+             * @description Number of pages at this pageSize, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 1
              */
             totalPages?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `pageSize` proves the walk is exhausted and this is empty.
+             */
+            nextPageToken?: string | null;
+            /**
+             * @description True when more than the server ceiling of payments matched, so the count stopped at the ceiling and total/totalPages are a lower bound.
+             * @example false
+             */
+            totalCapped?: boolean | null;
         };
         ListLeadTraderClosedTradesResponse: {
             closedTrades?: components["schemas"]["ClosedTrade"][] | null;
@@ -7484,22 +7582,37 @@ export interface components {
         ListManagedMarketAssignmentsResponse: {
             /** @description Expected assignments, including phases currently unable to quote. */
             items?: components["schemas"]["ManagedMarketAssignment"][] | null;
-            /** Format: uint32 */
+            /**
+             * Format: uint32
+             * @description Exact: a maker's assignment inventory is a small bounded set.
+             */
             total?: number | null;
             /** Format: uint32 */
-            page?: number | null;
-            /** Format: uint32 */
             pageSize?: number | null;
             inventoryObservedAt?: string | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `page_size` proves the walk is exhausted and this is empty.
+             */
+            nextPageToken?: string | null;
         };
         ListMarginAccountsResponse: {
             accounts?: components["schemas"]["MarginAccountSummary"][] | null;
-            /** Format: uint32 */
+            /**
+             * Format: uint32
+             * @description Exact: a user's margin accounts and risk buckets are a small bounded set,
+             *      counted in memory after the repricing pass.
+             */
             total?: number | null;
             /** Format: uint32 */
-            page?: number | null;
-            /** Format: uint32 */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page. The whole set is already in memory, so over-fetching is free and an
+             *      empty token is the definitive end of the walk.
+             */
+            nextPageToken?: string | null;
         };
         ListMyFollowersResponse: {
             followers?: components["schemas"]["Follower"][] | null;
@@ -7554,12 +7667,6 @@ export interface components {
              * @example 3
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @description Current page number
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -7572,32 +7679,47 @@ export interface components {
              * @example 1
              */
             totalPages?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `page_size` proves the walk is exhausted and this is empty.
+             */
+            nextPageToken?: string | null;
         };
         ListPositionHistoryResponse: {
             events?: components["schemas"]["PositionHistoryEvent"][] | null;
-            /**
-             * Format: uint32
-             * @description Matching position-history events. 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 history than the listing can page through reads the cap, not its lifetime total.
-             * @example 150
-             */
-            total?: number | null;
-            /** Format: uint32 */
-            page?: number | null;
             /** Format: uint32 */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one SQL statement with one global ORDER BY, so a
+             *      page shorter than `pageSize` proves the walk is exhausted and this is
+             *      empty. A non-empty token always has at least one further row behind it.
+             */
+            nextPageToken?: string | null;
         };
         ListPositionsResponse: {
             positions?: components["schemas"]["Position"][] | null;
             /**
              * Format: uint32
-             * @description Matching positions. 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 positions than the listing can page through reads the cap, not its lifetime total.
+             * @description Number of positions matching the filter, bounded by the server ceiling — a lower bound when totalCapped is true.
              * @example 150
              */
             total?: number | null;
             /** Format: uint32 */
-            page?: number | null;
-            /** Format: uint32 */
             pageSize?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one SQL statement with one global ORDER BY, so a
+             *      page shorter than `pageSize` proves the walk is exhausted and this is
+             *      empty. A non-empty token always has at least one further row behind it.
+             */
+            nextPageToken?: string | null;
+            /**
+             * @description True when more than the server ceiling of positions matched, so the count stopped at the ceiling and total is a lower bound. False when total is exact, including exactly the ceiling.
+             * @example false
+             */
+            totalCapped?: boolean | null;
         };
         ListSubAccountsResponse: {
             subAccounts?: components["schemas"]["SubAccount"][] | null;
@@ -7733,6 +7855,9 @@ export interface components {
              *      bucket cannot be released at all, and the parent margin account is
              *      charged at most its allocation, the loss past it being the insurance
              *      fund's.
+             *
+             *      Printed truncated toward zero at the quote asset's precision, so the
+             *      printed amount itself is always accepted.
              */
             withdrawableCollateral?: string | null;
             totalPositionNotional?: string | null;
@@ -7788,7 +7913,8 @@ export interface components {
              *
              *      Present only on risk-bucket summary rows served from a live risk engine
              *      snapshot; absent on parent rows and on persisted-fallback reads, where
-             *      neither of the gate's terms is reconstructable.
+             *      neither of the gate's terms is reconstructable. Printed truncated toward
+             *      zero at the quote asset's precision, like `withdrawable_collateral`.
              */
             availableOrderCollateral?: string | null;
             /**
@@ -8172,10 +8298,9 @@ export interface components {
              *      realized PnL and funding, less what risk buckets have allocated:
              *      `min(net deposits + settled realized PnL - bucket allocations,
              *      free_collateral - max(unrealized_pnl, 0))`, floored at zero. This is the
-             *      bound the engine's gates actually enforce. It agrees with
-             *      `MarginAccountSummary.withdrawable_collateral` up to quote-decimal
-             *      truncation: this surface truncates toward zero at the quote asset's
-             *      precision, while the margin-accounts surface may carry sub-tick tails.
+             *      bound the engine's gates actually enforce. The same figure as
+             *      `MarginAccountSummary.withdrawable_collateral`: both surfaces truncate it
+             *      toward zero at the quote asset's precision.
              *
              *      Size transfers-out, withdrawals, and new isolated/first-use positions
              *      from this field; `parent_available_collateral` remains the trading-margin
@@ -8234,10 +8359,8 @@ export interface components {
              *
              *      This is the largest accepted transfer-out, and every smaller amount is
              *      accepted too. It is zero on a risk bucket that is not `NORMAL` and on one
-             *      whose realized loss has used up its allocation. Agrees with the
-             *      risk-bucket rows' `MarginAccountSummary.withdrawable_collateral` up to
-             *      quote-decimal truncation (this surface truncates toward zero; that one
-             *      may carry sub-tick tails).
+             *      whose realized loss has used up its allocation. The same figure as the
+             *      risk-bucket rows' `MarginAccountSummary.withdrawable_collateral`.
              */
             withdrawableCollateral?: string | null;
             /**
@@ -8488,6 +8611,34 @@ export interface components {
              * @example 918342
              */
             version?: number | null;
+            /**
+             * @description RFC 3339 instant at which this position OPENED: the fill that took its
+             *      exposure from zero to non-zero. Time held is now minus opened_at for an
+             *      OPEN position, and updated_at minus opened_at for a terminal one. It never
+             *      changes for the life of the position id; a flip closes the position and
+             *      opens a new one, with a new id and its own opened_at.
+             *
+             *      Served from the matching engine's record of the opening fill while the
+             *      engine holds the position, and from the persisted row otherwise. The row
+             *      is written from the same fill's durable stamp, which comes from the
+             *      sequencer's non-decreasing stamp clock rather than the engine's wall
+             *      clock. The two readings normally agree to within one sequencer step, but
+             *      while the stamp clock is held ahead of a lagging host clock they differ by
+             *      that lead (`matching_engine_stamp_clock_live_lead_ms`), so a position's
+             *      value can move by it when the engine restarts and re-reads the row. Clamp
+             *      a computed time held at zero.
+             *
+             *      Absent when the opening instant is unknown, never filled with the read
+             *      instant. Positions opened before this field existed carry the persisted
+             *      row's value, which can trail the opening fill by the persistence lag
+             *      where the fill could not be recovered.
+             *
+             *      Not versioned, and not guaranteed constant at a given `version`: a
+             *      one-off operator correction can move it earlier without advancing the
+             *      version. Take it from the newest payload rather than skipping it on an
+             *      equal version.
+             */
+            openedAt?: string | null;
         };
         PositionHistoryEvent: {
             id?: string | null;
@@ -8797,7 +8948,7 @@ export interface components {
             source?: string | null;
             /**
              * Format: int32
-             * @description Referral level the caller earns from this source at: 1 (direct), 2, or 3.
+             * @description Referral level the caller earns from this source at: 1 (direct), 2, and so on (at most 10). Rows at a level deeper than PitPass rewards today are earlier earnings, kept as history.
              * @example 1
              */
             level?: number | null;
@@ -8830,6 +8981,10 @@ export interface components {
          *      ever pays in more than one reward token, atomic units across tokens are not
          *      additive, so read the per-token `earnings_by_source` rows for a correct
          *      breakdown.
+         *
+         *      `by_level` covers every level with earnings. `level1_earned`,
+         *      `level2_earned` and `level3_earned` are deprecated: they carry levels 1 to 3
+         *      for older clients and say nothing about deeper levels.
          */
         ReferralEarningsSummary: {
             /**
@@ -8838,20 +8993,25 @@ export interface components {
              */
             totalEarned?: string | null;
             /**
-             * @description Total earned from direct (L1) referees, in RAW atomic units.
+             * @deprecated
+             * @description DEPRECATED: use `byLevel`. Total earned from direct (L1) referees, in RAW atomic units.
              * @example 900000
              */
             level1Earned?: string | null;
             /**
-             * @description Total earned from L2 downline, in RAW atomic units.
+             * @deprecated
+             * @description DEPRECATED: use `byLevel`. Total earned from L2 downline, in RAW atomic units.
              * @example 400000
              */
             level2Earned?: string | null;
             /**
-             * @description Total earned from L3 downline, in RAW atomic units.
+             * @deprecated
+             * @description DEPRECATED: use `byLevel`. Total earned from L3 downline, in RAW atomic units.
              * @example 100000
              */
             level3Earned?: string | null;
+            /** @description All-time credited earnings per referral level, ascending by level, one entry per level the caller has earned at (levels with nothing earned are omitted). Covers every level, including levels deeper than PitPass rewards today. */
+            byLevel?: components["schemas"]["LevelEarnings"][] | null;
         };
         /** @description A single reward the caller has earned, one row per referred trade × level. */
         ReferralRewardEntry: {
@@ -8862,7 +9022,7 @@ export interface components {
             source?: string | null;
             /**
              * Format: int32
-             * @description Referral level this reward was paid at: 1 (direct, 30%), 2 (15%), or 3 (5%).
+             * @description Referral level this reward was paid at: 1 for the direct referrer, 2 for the referrer's referrer, and so on (at most 10).
              * @example 1
              */
             level?: number | null;
@@ -8903,7 +9063,7 @@ export interface components {
             display?: string | null;
             /**
              * Format: int32
-             * @description Depth below the caller: 1 (the caller referred this wallet), 2, or 3.
+             * @description Depth below the caller: 1 (the caller referred this wallet), 2, and so on up to the configured reward depth (at most 10).
              */
             level?: number | null;
             /** @description Wallet address of the referrer of this node — the caller for a level-1 node. */
@@ -8915,7 +9075,7 @@ export interface components {
             referredAt?: string | null;
             /**
              * Format: uint32
-             * @description How many wallets this node has referred. Expand the node (request it as `parent`) when this is above 0. Always 0 at level 3, the deepest level shown.
+             * @description How many wallets this node has referred. Expand the node (request it as `parent`) when this is above 0. Always 0 at the deepest rewarded level, the deepest level shown.
              */
             refereeCount?: number | null;
             /** @description What the caller has earned from this wallet's own trades, across every token, in RAW atomic units. `0` for a wallet that has not traded yet. */
@@ -8932,7 +9092,7 @@ export interface components {
             display?: string | null;
             /**
              * Format: int32
-             * @description How far above the caller this ancestor is: 1 (the caller's direct referrer), 2, or 3.
+             * @description How far above the caller this ancestor is: 1 (the caller's direct referrer), 2, and so on up to the configured reward depth (at most 10).
              */
             level?: number | null;
         };
@@ -9081,12 +9241,15 @@ export interface components {
              */
             maintenanceMarginRatio?: string | null;
             /**
-             * @deprecated
-             * @description DEPRECATED compatibility alias. This value is a maximum absolute base-asset quantity, not a notional. Use maxPositionSize.
+             * @description The most USD notional a position may hold at this bracket's max leverage: the next bracket's lowerBoundNotional, or the market's position cap on the top bracket. A position is valued at the order's price. Below the top bracket the cap is exclusive, since a notional at the next bound already sits in the next bracket. An order at a given leverage may take its position up to the cap of the highest bracket whose maxLeverage allows that leverage.
+             * @example 100000000
              */
             maxPositionNotional?: string | null;
-            /** @description Maximum authoritative absolute position size in base-asset quantity. A market-wide cap, repeated on every tier rather than varying per bracket. */
-            maxPositionSize?: string | null;
+            /**
+             * @deprecated
+             * @description DEPRECATED and no longer set: positions are capped in notional per bracket. Use maxPositionNotional.
+             */
+            maxPositionSize?: string | null;
             /**
              * Format: uint32
              * @description 1-based bracket index within the market's ladder; 1 is the lowest bracket.
@@ -9999,6 +10162,11 @@ export interface components {
              * @example USDC
              */
             quoteAssetName?: string | null;
+            /**
+             * @description Isolated-only market: cross margin may only reduce a position here. An order from a CROSS risk bucket that is not reduce-only is rejected with the error code CROSS_MARGIN_NOT_ALLOWED; open the position with margin_mode ISOLATED instead
+             * @example false
+             */
+            isolatedOnly?: boolean | null;
         };
         /**
          * @description Trailing stop leg (0XM-2827). Reduce-only MARKET close whose trigger trails
@@ -10067,7 +10235,8 @@ export interface components {
             /**
              * @description The largest amount a further transfer-out will accept after this one.
              *      See `MarginAccountSummary.withdrawable_collateral`: this is an
-             *      allocation-bounded figure, not clamped equity headroom.
+             *      allocation-bounded figure, not clamped equity headroom. Truncated toward
+             *      zero at the collateral asset's precision.
              */
             newWithdrawableCollateral?: string | null;
             strategyKey?: string | null;
@@ -10076,6 +10245,11 @@ export interface components {
             asset?: string | null;
             amount?: string | null;
         };
+        TransferCollateralFromSubAccountRequest: {
+            /** @description The caller's sub-account the collateral leaves. */
+            marginAccountId?: string | null;
+            amount?: string | null;
+        };
         TransferCollateralRequest: {
             /** @description Collateral asset symbol or address. */
             asset?: string | null;
@@ -10121,7 +10295,8 @@ export interface components {
             /**
              * @description The largest amount a further transfer-out will accept after this one.
              *      See `MarginAccountSummary.withdrawable_collateral`: this is an
-             *      allocation-bounded figure, not clamped equity headroom.
+             *      allocation-bounded figure, not clamped equity headroom. Truncated toward
+             *      zero at the collateral asset's precision.
              */
             newWithdrawableCollateral?: string | null;
             strategyKey?: string | null;
@@ -10207,6 +10382,11 @@ export interface components {
              */
             marginAccountId?: string | null;
         };
+        TransferCollateralToSubAccountRequest: {
+            /** @description The caller's sub-account that receives the collateral. */
+            marginAccountId?: string | null;
+            amount?: string | null;
+        };
         TransferRewardsRequest: {
             /**
              * @description Reward token contract address (0x-prefixed) to transfer.
@@ -10770,10 +10950,26 @@ export interface operations {
     get_user_balances: {
         parameters: {
             query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the lowest token address.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      This listing has no database page to walk: it reads every balance row,
+                 *      overlays the matching engine's authoritative amounts (which can add rows
+                 *      the projection has not written yet and drop rows the engine has zeroed),
+                 *      and pages that in-memory set. The walk therefore seeks by KEY on
+                 *      `(token, asset_id)` — immutable, present on every row including a
+                 *      live-only one — rather than by index, so a balance that appears or
+                 *      vanishes mid-walk no longer shifts the rows behind it across the resume
+                 *      point and duplicate or skipped rows. `total` and `totalPages` are exact:
+                 *      the set is bounded by the asset universe, so there is nothing to cap.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -10885,10 +11081,28 @@ export interface operations {
                 tradingPairId?: string;
                 positionId?: string;
                 marginAccountId?: string;
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest payment.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      The walk seeks on `(created_at, id)` descending. Not `period_end`, which
+                 *      the removed page-number mode led its sort with: that column is nullable
+                 *      and the risk engine leaves it unset when a payment carries no window,
+                 *      while `created_at` is always stamped (it falls back to the settlement
+                 *      instant). The `id` tie-break is new — the removed order had none, so a
+                 *      page boundary inside one funding window could already repeat or drop a
+                 *      payment.
+                 *
+                 *      `total` and `totalPages` are populated — bounded by the server count
+                 *      ceiling, see `totalCapped`. Filters must match the request that produced
+                 *      the token, or the request is rejected 400.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -11396,9 +11610,7 @@ export interface operations {
     get_user_movements: {
         parameters: {
             query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
                 /** @description Transaction type */
                 transactionType?: "DEPOSIT" | "WITHDRAWAL" | "TRADE" | "FEE" | "FUNDING" | "LIQUIDATION" | "INTEREST" | "REWARD" | "CHAIN_SYNC";
@@ -11408,6 +11620,19 @@ export interface operations {
                 assetId?: string;
                 /** @description Sort direction for createdAt */
                 orderBy?: "ASC" | "DESC";
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest row (or the oldest, when `orderBy` is ASC).
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      Every walk covers the ledger and funding arms merged. `total` and
+                 *      `totalPages` are populated — bounded by the server count ceiling, see
+                 *      `totalCapped`. Filters and `orderBy` must match the request that produced
+                 *      the token, or the request is rejected 400.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -11874,7 +12099,7 @@ export interface operations {
                  *       - Omitted or empty string (""): start a cursor walk with no prior
                  *         position, from the newest row.
                  *       - Non-empty: an opaque cursor from a previous response's
-                 *         `next_page_token`; results resume immediately after that position.
+                 *         `nextPageToken`; results resume immediately after that position.
                  *
                  *      Every walk covers full trade history — hot and archived rows merged. The
                  *      response carries no item count: this listing's table is too large to count
@@ -11929,15 +12154,34 @@ export interface operations {
     };
     list_application_balances: {
         parameters: {
-            query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+            query: {
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
                 /** @description User identifier (UUID) */
                 userId?: string;
                 /** @description Asset identifier (UUID) */
                 assetId?: string;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      Ordered by balance id ascending. NOT by `updated_at`, which the removed
+                 *      offset mode sorted on: that column changes on every balance movement, so
+                 *      a walk over it could repeat or skip rows with no concurrent insert at
+                 *      all.
+                 *
+                 *      `total` and `totalPages` are populated — bounded by the server count
+                 *      ceiling, see `totalCapped`.
+                 *
+                 *      Filters must match the request that produced the token, or the request
+                 *      is rejected 400.
+                 */
+                pageToken?: string;
+                /** @description Application client ID */
+                clientId: string;
             };
             header?: never;
             path?: never;
@@ -11954,15 +12198,22 @@ export interface operations {
                     "application/json": components["schemas"]["ListAppBalancesResponse"];
                 };
             };
-            /** @description Bad request */
+            /** @description Bad request (missing client_id, invalid filter or page token) */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Unauthorized - Invalid or missing x-server-key */
-            401: {
+            /** @description No active application has this client_id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Public read rate limit exceeded for this client IP; retry after the interval in details.retryAfter */
+            429: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -12034,10 +12285,8 @@ export interface operations {
     };
     list_application_movements: {
         parameters: {
-            query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+            query: {
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
                 /** @description User identifier (UUID) */
                 userId?: string;
@@ -12047,6 +12296,23 @@ export interface operations {
                 entryType?: "CREDIT" | "DEBIT" | "LOCK" | "UNLOCK" | "FEE";
                 /** @description Asset identifier (UUID) */
                 assetId?: string;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest movement.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      The response carries no item count: `user_ledger` is too large to count
+                 *      behind a filter. A movement with no recorded timestamp is not listed —
+                 *      the column is nullable, and a NULL has no position in the sort key.
+                 *
+                 *      Filters must match the request that produced the token, or the request
+                 *      is rejected 400.
+                 */
+                pageToken?: string;
+                /** @description Application client ID */
+                clientId: string;
             };
             header?: never;
             path?: never;
@@ -12063,15 +12329,22 @@ export interface operations {
                     "application/json": components["schemas"]["ListAppMovementsResponse"];
                 };
             };
-            /** @description Bad request */
+            /** @description Bad request (missing client_id, invalid filter or page token) */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Unauthorized - Invalid or missing x-server-key */
-            401: {
+            /** @description No active application has this client_id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Public read rate limit exceeded for this client IP; retry after the interval in details.retryAfter */
+            429: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -12088,10 +12361,8 @@ export interface operations {
     };
     list_application_orders: {
         parameters: {
-            query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+            query: {
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
                 /** @description Order status (single value or comma-separated list) */
                 status?: string;
@@ -12103,6 +12374,23 @@ export interface operations {
                 side?: "BUY" | "SELL";
                 /** @description Order type */
                 orderType?: "LIMIT" | "MARKET" | "STOP_LOSS" | "TAKE_PROFIT" | "STOP_LIMIT" | "TRAILING_STOP";
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      Every walk covers full order history — hot and archived rows merged.
+                 *      The response carries no item count: `orders_all` is too large to count
+                 *      behind a filter.
+                 *
+                 *      Filters must match the request that produced the token, or the request
+                 *      is rejected 400.
+                 */
+                pageToken?: string;
+                /** @description Application client ID */
+                clientId: string;
             };
             header?: never;
             path?: never;
@@ -12119,15 +12407,22 @@ export interface operations {
                     "application/json": components["schemas"]["ListAppOrdersResponse"];
                 };
             };
-            /** @description Bad request */
+            /** @description Bad request (missing client_id, invalid filter or page token) */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Unauthorized - Invalid or missing x-server-key */
-            401: {
+            /** @description No active application has this client_id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Public read rate limit exceeded for this client IP; retry after the interval in details.retryAfter */
+            429: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -12144,8 +12439,10 @@ export interface operations {
     };
     get_application_stats: {
         parameters: {
-            query?: {
+            query: {
                 since?: string;
+                /** @description Application client ID */
+                clientId: string;
             };
             header?: never;
             path?: never;
@@ -12162,15 +12459,22 @@ export interface operations {
                     "application/json": components["schemas"]["GetAppStatsResponse"];
                 };
             };
-            /** @description Bad request */
+            /** @description Bad request (missing client_id, invalid filter or page token) */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Unauthorized - Invalid or missing x-server-key */
-            401: {
+            /** @description No active application has this client_id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Public read rate limit exceeded for this client IP; retry after the interval in details.retryAfter */
+            429: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -12188,15 +12492,34 @@ export interface operations {
     list_application_users: {
         parameters: {
             query: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
                 isActive?: boolean;
                 /** @description Account type filter */
                 accountType?: "master" | "sub";
                 /** @description Wallet address */
                 address: string;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      Ordered by user id ascending, NOT newest-first: `users.created_at` is
+                 *      nullable, so it cannot be a total keyset key, and excluding the rows
+                 *      without one would hide users from the listing an application
+                 *      reconciles against.
+                 *
+                 *      `total` and `totalPages` are populated — bounded by the server count
+                 *      ceiling, see `totalCapped`.
+                 *
+                 *      Filters must match the request that produced the token, or the request
+                 *      is rejected 400.
+                 */
+                pageToken?: string;
+                /** @description Application client ID */
+                clientId: string;
             };
             header?: never;
             path?: never;
@@ -12213,15 +12536,22 @@ export interface operations {
                     "application/json": components["schemas"]["ListAppUsersResponse"];
                 };
             };
-            /** @description Bad request */
+            /** @description Bad request (missing client_id, invalid filter or page token) */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Unauthorized - Invalid or missing x-server-key */
-            401: {
+            /** @description No active application has this client_id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Public read rate limit exceeded for this client IP; retry after the interval in details.retryAfter */
+            429: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -12501,7 +12831,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Refused: BuilderCodes is disabled, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
+            /** @description Refused: neither the revenue share nor builder fees are switched on, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -12571,7 +12901,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Refused: BuilderCodes is disabled, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
+            /** @description Refused: the caller is delegated or is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -12619,7 +12949,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Refused: BuilderCodes is disabled, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
+            /** @description Refused: the caller is delegated or is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -12645,10 +12975,48 @@ export interface operations {
     list_buildercode_payouts: {
         parameters: {
             query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest credit.
+                 *       - 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, served by
+                 *      `idx_buildercode_payouts_application_created_id`, whose leading key is the
+                 *      caller's own application and whose remaining keys are this seek's, both
+                 *      descending. Both key columns are NOT NULL and fixed for a credit's
+                 *      lifetime. (Spelled without the column list on purpose: the read contract
+                 *      test asserts this request message never mentions a caller-selected
+                 *      identity.)
+                 *
+                 *      This REPLACES the removed mode's `(sequence, sequence_ordinal, created_at,
+                 *      id)` order, whose two leading columns are nullable — no backfill exists
+                 *      for credits written before they did — and a nullable leading key cannot be
+                 *      a total cursor key: the NULL rows sort together at one end, and a seek
+                 *      through them would need a COALESCE no index covers.
+                 *
+                 *      ORDERING CHANGE, not just a pagination change. The new key is total and
+                 *      stable — a page can neither skip nor duplicate a credit — but it is NOT
+                 *      chronological inside one persistor batch. `created_at` defaults to `NOW()`,
+                 *      which is transaction-start time, so every credit one batch writes shares an
+                 *      identical timestamp; the `id` tie-break defaults to `gen_random_uuid()`,
+                 *      which the persistor leaves alone. So within a batch the order is arbitrary
+                 *      and a LATER fill can be listed ahead of an earlier one. The removed order
+                 *      led with `sequence` and `sequence_ordinal` precisely because those carry
+                 *      the engine's fill order, and one entry routinely holds several credits (a
+                 *      taker sweeping N makers, or a flattened `BatchCreateOrders`). Preserving
+                 *      fill chronology would need those columns backfilled first, which is not
+                 *      possible for credits written before they existed. Across batches the order
+                 *      is still newest-first.
+                 *
+                 *      `total` and `total_pages` are populated and exact, and count the rows the
+                 *      `kind` filter selects. Filters must match the request that produced the
+                 *      token, or the request is rejected 400.
+                 */
+                pageToken?: string;
                 /** @description Only return BuilderCodes payouts of this payout kind: REVENUE_SHARE (the frontend's share of Monaco's fee) or BUILDER_FEE (ordinary builder fees charged to takers and credited to enrolled applications). Omit for every kind. */
                 kind?: "REVENUE_SHARE" | "BUILDER_FEE";
             };
@@ -12681,7 +13049,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Refused: BuilderCodes is disabled, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
+            /** @description Refused: the caller is delegated or is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -12729,7 +13097,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Refused: BuilderCodes is disabled, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
+            /** @description Refused: the caller is delegated or is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -12777,7 +13145,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Refused: BuilderCodes is disabled or the caller is delegated (gRPC: PERMISSION_DENIED) */
+            /** @description Refused: the caller is delegated (gRPC: PERMISSION_DENIED) */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -12829,7 +13197,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Refused: BuilderCodes is not enabled, or the caller is a delegated-agent session (gRPC: PERMISSION_DENIED) */
+            /** @description Refused: the caller is a delegated-agent session (gRPC: PERMISSION_DENIED) */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -14377,10 +14745,24 @@ export interface operations {
     list_managed_market_assignments: {
         parameters: {
             query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the oldest assignment.
+                 *       - 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)` ascending — the order this listing
+                 *      already read in, and the order
+                 *      `idx_market_launch_maker_inventory (maker_user_id, maker_application_id,
+                 *      created_at, id)` is built for, so the seek stays an index scan. Both
+                 *      columns are NOT NULL and fixed for a launch's lifetime. `total` is
+                 *      populated and exact: a maker's assignment inventory is a small bounded
+                 *      set.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -14475,9 +14857,7 @@ export interface operations {
     list_margin_accounts: {
         parameters: {
             query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
                 /**
                  * @description Keep only risk-bucket rows in this state (see `risk_bucket_state`). A
@@ -14486,6 +14866,34 @@ export interface operations {
                 state?: string;
                 /** @description Trading pair identifier (UUID) */
                 tradingPairId?: string;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the lowest margin account id.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      This listing has no database page to walk: one row is a margin account
+                 *      and one row is a risk bucket, each repriced against live marks and the
+                 *      engine's bounds, so the set is built in memory and paged there. The walk
+                 *      seeks by KEY on
+                 *      `(margin_account_id, trading_pair_id, risk_bucket_id, strategy_key)` —
+                 *      every component immutable for the row's lifetime, the parent row sorting
+                 *      ahead of its buckets — rather than by index, so a bucket that opens or
+                 *      closes mid-walk no longer shifts the rows behind it across the resume
+                 *      point. The strategy key is part of the key because an auto bucket the
+                 *      engine has not materialized yet carries no `risk_bucket_id`, and one
+                 *      account and pair can hold several strategies; such a row sorts under the
+                 *      id its bucket will carry once the engine projects it, derived from the
+                 *      account and pair, so provisioning completing mid-walk cannot move the row
+                 *      across the resume point and serve the same risk bucket twice. `total` is
+                 *      exact: a user's accounts and buckets are a small bounded set, counted in
+                 *      memory.
+                 *
+                 *      Filters must match the request that produced the token, or the request is
+                 *      rejected 400.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -14625,10 +15033,21 @@ export interface operations {
         parameters: {
             query?: {
                 movementType?: string;
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest movement — this listing always sorts
+                 *         newest-first.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      The response carries no item count: the underlying ledger is too large to
+                 *      count behind a filter. `movementType` must match the request that produced
+                 *      the token, or the request is rejected 400.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path: {
@@ -14886,10 +15305,13 @@ export interface operations {
         parameters: {
             query?: {
                 movementType?: string;
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description See `GetMarginAccountMovementsRequest.page_token`: the same cursor walk,
+                 *      scoped to the caller's parent margin account.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -15073,6 +15495,80 @@ export interface operations {
             };
         };
     };
+    transfer_collateral_to_sub_account: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The caller's sub-account that receives the collateral.
+                 * @example 2b1a5f9c-0000-4000-8000-000000000001
+                 */
+                marginAccountId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TransferCollateralToSubAccountRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TransferCollateralResponse"];
+                };
+            };
+            /** @description Movement rate limit exceeded — withdrawals and collateral transfers share a per-user budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    transfer_collateral_from_sub_account: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description The caller's sub-account the collateral leaves.
+                 * @example 2b1a5f9c-0000-4000-8000-000000000001
+                 */
+                marginAccountId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TransferCollateralFromSubAccountRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TransferCollateralResponse"];
+                };
+            };
+            /** @description Movement rate limit exceeded — withdrawals and collateral transfers share a per-user budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     list_all_funding_history: {
         parameters: {
             query?: {
@@ -15080,12 +15576,30 @@ export interface operations {
                 startTime?: number;
                 /** @description End time as Unix timestamp (milliseconds) */
                 endTime?: number;
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
                 /** @description Sort direction for settledAt */
                 orderBy?: "ASC" | "DESC";
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest settlement (the oldest when `orderBy` is
+                 *         ASC).
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      The walk seeks on `(settled_at, id)` in the requested direction.
+                 *      `settled_at` is NOT NULL and never changes once a window settles, and the
+                 *      `id` tie-break makes the key total — the removed page-number mode ordered
+                 *      by `(settled_at, trading_pair_id, epoch)` with no tie-break, so a page
+                 *      boundary between two settlements sharing that triple could repeat or drop
+                 *      a row.
+                 *
+                 *      `total` is populated — bounded by the server count ceiling, see
+                 *      `totalCapped`. Filters and `orderBy` must match the request that produced
+                 *      the token, or the request is rejected 400.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -15271,12 +15785,29 @@ export interface operations {
                 startTime?: number;
                 /** @description End time as Unix timestamp (milliseconds) */
                 endTime?: number;
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
-                /** @description Sort direction for createdAt */
+                /** @description Sort direction for settledAt */
                 orderBy?: "ASC" | "DESC";
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest settlement (the oldest when `orderBy` is
+                 *         ASC).
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      The walk seeks on `(settled_at, id)` in the requested direction.
+                 *      `settled_at` is NOT NULL and never changes once a window settles, and the
+                 *      `id` tie-break makes the key total — the removed page-number mode ordered
+                 *      by `epoch` with no tie-break, so a page boundary between two
+                 *      settlements sharing it could repeat or drop a row.
+                 *
+                 *      `total` is populated — bounded by the server count ceiling, see
+                 *      `totalCapped`. Filters and `orderBy` must match the request that produced
+                 *      the token, or the request is rejected 400.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path: {
@@ -16844,7 +17375,15 @@ export interface operations {
     };
     get_my_referral_downline: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description `earningsBySource` rows per page (max 500) */
+                pageSize?: number;
+                /**
+                 * @description Opaque cursor from a previous response's `nextPageToken`; omit or send an
+                 *      empty string for the first page.
+                 */
+                pageToken?: string;
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -16924,7 +17463,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description `parent` is not the caller or one of the caller's own L1/L2 referees */
+            /** @description `parent` is not the caller or one of the caller's own expandable referees */
             404: {
                 headers: {
                     [name: string]: unknown;
@@ -17056,10 +17595,53 @@ export interface operations {
                 tradingPairId?: string;
                 /** @description Order status (single value or comma-separated list) */
                 status?: string;
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      ORDER DEPENDS ON THE FILTER, because the two cases are served from
+                 *      different places:
+                 *
+                 *       - `status=OPEN` is answered from the matching engine's live view, which
+                 *         carries no timestamps for a position the persistor has not written
+                 *         yet. It is ordered by `(marginAccountId, tradingPairId, positionId)`
+                 *         ascending — stable and total, but UUID order, NOT newest-first.
+                 *       - Every other filter reads persisted rows, ordered by the IMMUTABLE
+                 *         `(opened_at, id)` descending: newest-opened first. The removed
+                 *         page-number mode sorted on `COALESCE(closed_at, last_funding_at,
+                 *         opened_at)`, which *advances* whenever a position takes a funding
+                 *         payment or closes, so rows moved across a resume point mid-walk;
+                 *         `opened_at` never changes after the insert. Order therefore differs
+                 *         from the removed mode's. One exception: an operator correction may
+                 *         move an OPEN position's `opened_at` EARLIER, never later, to its
+                 *         opening fill. A walk in flight while that runs can return such a
+                 *         position a second time, but cannot skip one: dedupe on `positionId`.
+                 *
+                 *      Those are two separate cursor spaces, so a token is only valid in the one
+                 *      that minted it, and crossing between them is ASYMMETRIC:
+                 *
+                 *       - A PERSISTED token offered to `status=OPEN` while the engine is
+                 *         reachable is served: the live branch does not recognise it, declines,
+                 *         and the persisted walk answers. That is what keeps a walk going which
+                 *         started on persisted rows because the engine was down at the time and
+                 *         has since come back.
+                 *       - A LIVE token offered after the engine becomes unreachable is NOT
+                 *         served. The live branch cannot answer at all, and the persisted
+                 *         decoder rejects the `src=live` token, so the request is a 400 and the
+                 *         walk has to start over. There is no way to carry a live position into
+                 *         the persisted ordering: the two relations do not share a sort key, and
+                 *         resuming at a key from the wrong one would skip or repeat rows
+                 *         silently, which is worse than the restart.
+                 *
+                 *      A token neither relation recognises is rejected 400, and so is one minted
+                 *      under different filters.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -17123,12 +17705,24 @@ export interface operations {
                 marginAccountId?: string;
                 /** @description Trading pair identifier (UUID) */
                 tradingPairId?: string;
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
                 /** @description When true, return only DECREASE, CLOSE, and LIQUIDATE execution rows. */
                 reductionOnly?: boolean;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest event — this listing always sorts
+                 *         newest-first.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      Every walk covers full position history — hot and archived rows merged.
+                 *      The response carries no item count: this listing's relation is too large
+                 *      to count behind a filter. Filters must match the request that produced the
+                 *      token, or the request is rejected 400.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;
@@ -17521,10 +18115,24 @@ export interface operations {
     get_trades: {
         parameters: {
             query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Max trades to return (max 100) */
+                /** @description Max trades to return (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the most recent trade (this listing always sorts
+                 *         newest-first).
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `next_page_token`; results resume immediately after that position.
+                 *
+                 *      The walk is a keyset seek on `(executed_at, id)`, both immutable once a
+                 *      trade is written, so a page can neither repeat nor skip a trade when new
+                 *      fills land mid-walk — the failure the removed page number had by
+                 *      construction on a table this endpoint appends to continuously.
+                 *      `trading_pair_id` is pinned inside the token, so a token minted for one
+                 *      pair is rejected rather than seeking into another pair's history.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path: {
@@ -17615,10 +18223,24 @@ export interface operations {
     list_pending_withdrawals: {
         parameters: {
             query?: {
-                /** @description Page number (1-indexed) */
-                page?: number;
-                /** @description Items per page (max 100) */
+                /** @description Items per page (max 1000) */
                 pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest pending withdrawal.
+                 *       - 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, withdrawal_index)` descending — the order
+                 *      this listing already read in, served by
+                 *      `idx_withdrawals_user_created (user_id, created_at DESC)`. `created_at` is
+                 *      NOT NULL and `withdrawal_index` is the table's primary key, assigned by
+                 *      the vault in request order, so the key is total and immutable. `total` is
+                 *      populated and exact: a user's unexecuted withdrawals are a small bounded
+                 *      set.
+                 */
+                pageToken?: string;
             };
             header?: never;
             path?: never;