@0xmonaco/types 1.0.73 → 1.0.74

package/dist/wire/schema.d.ts

@@ -297,7 +297,9 @@ export interface paths {
          *      address — and a per-order mode always overrides it. The write is sequenced
          *      through the matching engine; on success the next order from the wallet
          *      family already resolves the new mode. Delegated-agent sessions cannot
-         *      change it.
+         *      change it. It spends the per-account settings-write rate limit (about one
+         *      write per second, burst 10) that the copy trading lead trader and follow
+         *      writes share.
          */
         put: operations["set_self_trade_prevention_default"];
         post?: never;
@@ -732,9 +734,10 @@ export interface paths {
          *
          *      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. Once charged, a new fee applies to orders placed after the
-         *      change within a few seconds; resting orders keep the fee they were placed
-         *      with.
+         *      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.
          *
          *      A refused change is **HTTP 409** / **FAILED_PRECONDITION** when the
          *      application is not enrolled with a payout address or has no changes left
@@ -940,6 +943,11 @@ export interface paths {
          *      retry with backoff, and an overload positively wants one. Only an UNTAGGED
          *      availability failure — matching-engine transport, timeout and fail-closed
          *      paths — carries the unknown outcome.
+         *
+         *      A claim spends the per-user movement budget withdrawals and collateral
+         *      transfers share. Over budget it is refused with **HTTP 429** /
+         *      **RESOURCE_EXHAUSTED** before it reaches the sequencer, so it committed
+         *      nothing and is safe to retry after the interval in `details.retryAfter`.
          */
         post: operations["claim_buildercode_rewards"];
         delete?: never;
@@ -975,7 +983,9 @@ export interface paths {
          *      `leader` handle that names a different leader is refused. `copyExisting`
          *      copies the leader's open positions into the new copy account at creation
          *      (see PreviewFollow for what that costs); it applies only to a create, and
-         *      an edit that sets it is refused.
+         *      an edit that sets it is refused. A create and an edit each spend the
+         *      per-account settings-write rate limit (about one write per second, burst
+         *      10) that UpsertLeadTrader and the self-trade-prevention default share.
          */
         post: operations["upsert_follow"];
         delete?: never;
@@ -1146,9 +1156,7 @@ export interface paths {
          *      There is no margin reduction: a follow exits by being stopped. Follow
          *      writes need a master account session (not a delegated agent or a
          *      sub-account). 404 unless the follow is yours; 409 while it is stopping
-         *      or once it is stopped, and when copy trading is not available on the
-         *      platform at all (the platform then runs copy trading exits only). It
-         *      spends the per-user movement budget withdrawals and collateral transfers
+         *      or once it is stopped. It spends the per-user movement budget withdrawals and collateral transfers
          *      share. It is not idempotent: a retry after a timeout whose first attempt
          *      landed adds the amount twice, so read the follow before retrying.
          */
@@ -1173,8 +1181,11 @@ export interface paths {
          * @description Stop a follow.
          *
          *      Stops mirroring the leader. Stopping one of your own follows only; the
-         *      follow is identified by its id. An exit is never gated beyond ownership,
-         *      except that a delegated agent session cannot stop a follow.
+         *      follow is identified by its id. An exit is never refused for the state
+         *      of the account or the platform. Only three things apply: ownership, the
+         *      refusal of a delegated agent session, and a per-account rate limit of
+         *      its own (about one stop per second, burst 20), which closes and follow
+         *      edits never spend.
          */
         post: operations["stop_follow"];
         delete?: never;
@@ -1232,7 +1243,9 @@ export interface paths {
          *      TraderCode handle. The profile is replaced as sent: an omitted `bio` or
          *      `minAllocation` clears it and an omitted `status` means ACTIVE; an
          *      omitted `shareBps` keeps the current share (the platform default on a
-         *      registration). A follower with a live follow cannot register.
+         *      registration). A follower with a live follow cannot register. It spends
+         *      the per-account settings-write rate limit (about one write per second,
+         *      burst 10) that UpsertFollow and the self-trade-prevention default share.
          */
         put: operations["upsert_lead_trader"];
         post?: never;
@@ -1360,7 +1373,10 @@ export interface paths {
          *
          *      Master accounts only. Creates (or updates, keyed on `agent_address`) a
          *      delegation linking the calling owner to an agent wallet, together with the
-         *      policy that constrains what the agent may do on the owner's behalf.
+         *      policy that constrains what the agent may do on the owner's behalf. An
+         *      owner holds at most 10 active, unexpired agents; a new one past that is
+         *      rejected until one is revoked or expires. Binding an agent to one margin
+         *      account (`allowed_margin_account_ids`) makes it that sub-account's key.
          */
         post: operations["upsert_delegated_agent"];
         delete?: never;
@@ -1412,7 +1428,8 @@ export interface paths {
          *      `ListDelegatedAgentOwners`) and a freshly generated session public key.
          *      The new session acts as the owner but records the agent's address for
          *      policy enforcement. Requires an active delegation for the (owner, agent)
-         *      pair. Session expiry is bounded by the delegation expiry, if set. Every
+         *      pair, and, when the delegation has an IP allowlist, a caller address
+         *      inside it. Session expiry is bounded by the delegation expiry. Every
          *      authenticated request and periodic WebSocket session revalidation requires
          *      the backing delegation to remain active and unexpired.
          */
@@ -1696,6 +1713,29 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/margin/accounts/{marginAccountId}/pnl": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * @description One margin account's own PnL: realized (settled on the account plus
+         *      still held in its open risk buckets) and unrealized (its positions
+         *      repriced at the latest risk marks). Transfers between the caller's
+         *      accounts are flows, not PnL, so the figures of the caller's accounts sum
+         *      to the owner-wide figure.
+         */
+        get: operations["get_margin_account_pnl"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/margin/accounts/{marginAccountId}/simulate-order-risk": {
         parameters: {
             query?: never;
@@ -1728,6 +1768,30 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/margin/collateral/transfer": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * @description Move collateral between the spot wallet, the caller's margin accounts and
+         *      their risk buckets. `from` and `to` each name the wallet or a margin
+         *      account (optionally one of its risk buckets). Supported moves: wallet to
+         *      the default margin account and back, margin account to margin account,
+         *      and margin account to one of its own risk buckets. The older transfer
+         *      routes keep working unchanged.
+         */
+        post: operations["transfer_collateral"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/margin/parent-margin-account": {
         parameters: {
             query?: never;
@@ -1849,6 +1913,56 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/margin/sub-accounts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * @description Open a sub-account: another margin account of the caller, keyed by
+         *      `subaccount_key`, with its own collateral and its own risk buckets. The
+         *      default margin account (key `default`) is the only one deposits and
+         *      withdrawals touch; fund a sub-account with `TransferCollateral`.
+         *      Re-creating the key of a closed sub-account re-opens the same account.
+         *      Keys starting with `copy:` are reserved. An owner may hold a limited
+         *      number of open sub-accounts, set by their weighted 14-day volume tier
+         *      (10 at the first tier, up to 50) or an admin override; a create past it
+         *      is refused. Copy-trading sub-accounts do not count.
+         */
+        post: operations["create_sub_account"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/margin/sub-accounts/{marginAccountId}/close": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * @description Close a sub-account. Refused unless it is flat: no position and no order,
+         *      conditional order or TWAP. Its flat, solvent risk buckets close in the
+         *      same step, and all of its remaining collateral moves to the default
+         *      margin account. A risk bucket in liquidation or bad debt refuses the
+         *      close, and nothing moves.
+         */
+        post: operations["close_sub_account"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/market/funding/history": {
         parameters: {
             query?: never;
@@ -2643,12 +2757,13 @@ export interface paths {
          * Get your referral position
          * @description Read your own referral position (self-scoped).
          *
-         *      Return the authenticated caller's referral position: their direct (L1)
-         *      referrer, the total rewards they have earned, and their most recent reward
-         *      rows. Self-scoped — identity comes only from the session, never a path id,
+         *      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.
+         *      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
-         *      `referrer` means the caller was not referred.
+         *      `referrer` and `upline` mean the caller was not referred.
          */
         get: operations["get_my_referral_position"];
         put?: never;
@@ -2687,6 +2802,41 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/pitpass/referrals/me/tree": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get one level of your referral tree
+         * @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
+         *      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.
+         *
+         *      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
+         *      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.
+         */
+        get: operations["get_my_referral_tree"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/pitpass/rewards/balance": {
         parameters: {
             query?: never;
@@ -2729,7 +2879,8 @@ export interface paths {
          *      trading balance under the authenticated application, making it tradeable
          *      immediately. Ledger-only (one shared vault + one backend ledger) — no
          *      on-chain transaction and no gas. Fails with 402 when the rewards balance is
-         *      insufficient.
+         *      insufficient. It spends the per-user movement budget withdrawals and
+         *      collateral transfers share.
          */
         post: operations["transfer_rewards"];
         delete?: never;
@@ -2769,7 +2920,13 @@ export interface paths {
          *      Submits a MARKET reduce-only close for every open position owned by the
          *      caller, optionally filtered to a single trading pair. Best-effort and
          *      partial: each position closes independently and per-position failures are
-         *      reported in `results` rather than aborting the batch.
+         *      reported in `results` rather than aborting the batch. Each close draws
+         *      one item from the risk-reduction rate limit (an empty call draws one).
+         *      The first 100 are charged before anything is sent: over budget, the
+         *      whole call is refused with 429 and nothing is closed. Past 100 open
+         *      positions the rest are charged 100 at a time as the call reaches them,
+         *      and those the budget does not cover are not sent: they come back in
+         *      `results` with `RATE_LIMIT_EXCEEDED`, to be retried.
          */
         post: operations["batch_close_all_positions"];
         delete?: never;
@@ -3944,7 +4101,7 @@ export interface components {
             amount?: string | null;
             /**
              * Format: int32
-             * @description Realized whole-basis-point rate for this credit after the Monaco-floor clamp, computed from the credited amount divided by the gross protocol take and truncated down. This can be lower than the configured BuilderCodes budget.
+             * @description Basis-point rate applied to this credit. For `BUILDER_FEE`, this is the normalized builder-fee rate charged to the taker. For `REVENUE_SHARE`, it is the realized whole-basis-point rate after the Monaco-floor clamp and can be lower than the configured BuilderCodes budget.
              * @example 1000
              */
             appliedBps?: number | null;
@@ -3954,7 +4111,7 @@ export interface components {
              */
             createdAt?: string | null;
             /**
-             * @description Payout category for this credit. `REVENUE_SHARE` is active; `BUILDER_FEE` is reserved and is not currently emitted.
+             * @description Payout category for this credit: `REVENUE_SHARE` for Monaco revenue sharing or `BUILDER_FEE` for an ordinary builder fee charged to the taker.
              * @example REVENUE_SHARE
              * @enum {string|null}
              */
@@ -4271,6 +4428,16 @@ export interface components {
             message?: string | null;
             submittedQuantity?: string | null;
         };
+        CloseSubAccountRequest: {
+            marginAccountId?: string | null;
+        };
+        CloseSubAccountResponse: {
+            marginAccountId?: string | null;
+            /** @description The default margin account that received the remaining collateral. */
+            defaultMarginAccountId?: string | null;
+            /** @description Collateral moved to the default margin account. */
+            amount?: string | null;
+        };
         ClosedTrade: {
             /**
              * Format: uuid
@@ -4299,6 +4466,17 @@ export interface components {
             /** @description Execution time (RFC 3339) */
             closedAt?: string | null;
         };
+        /**
+         * @description One side of a `TransferCollateral`: the spot wallet, or a margin account
+         *      and optionally one of its risk buckets.
+         */
+        CollateralTransferEndpoint: {
+            /** @description The spot wallet. Set exactly one of `wallet` and `margin_account_id`. */
+            wallet?: boolean | null;
+            marginAccountId?: string | null;
+            /** @description A risk bucket of `margin_account_id`. */
+            riskBucketId?: string | null;
+        };
         ConditionalOrder: {
             conditionalOrderId?: string | null;
             /** Format: uuid */
@@ -4598,6 +4776,23 @@ export interface components {
              */
             trailingStopOrderId?: string | null;
         };
+        CreateSubAccountRequest: {
+            /**
+             * @description Sub-account key: up to 64 letters, digits, `_`, `-`, `.` or `:`. Keys
+             *      starting with `copy:` are reserved, and `default` names the default
+             *      margin account.
+             */
+            subaccountKey?: string | null;
+            /** @description Optional display label. */
+            label?: string | null;
+        };
+        CreateSubAccountResponse: {
+            marginAccountId?: string | null;
+            subaccountKey?: string | null;
+            /** @description Values: ACTIVE. */
+            marginAccountState?: string | null;
+            label?: string | null;
+        };
         CreateTwapOrderRequest: {
             /**
              * Format: uuid
@@ -4811,6 +5006,8 @@ export interface components {
              * @description Legacy field; no concurrent open-order cap is enforced. New or updated policies leave it unset.
              */
             maxOpenOrders?: number | null;
+            /** @description IP addresses and CIDR ranges the agent may create its delegated session from, normalized. Empty allows any address. */
+            ipAllowlist?: string[] | null;
         };
         DelegatedAgentOwner: {
             /**
@@ -5144,12 +5341,13 @@ export interface components {
              *      margin account yet.
              *
              *      This is NOT trading headroom for existing cross exposure. It is bounded
-             *      by allocation (principal not earmarked by risk buckets) as well as by
+             *      by allocation (net deposits plus settled realized PnL not allocated to
+             *      risk buckets) as well as by
              *      margin requirements, and an unrealized gain does not raise it: a
              *      mark-to-market gain is initial margin against existing cross exposure but
              *      may not fund an exit. `MarginAccountSummary.free_collateral` credits that
              *      gain in full and remains the trading-margin headroom for existing cross
-             *      exposure — but a NEW isolated or first-use position allocates principal
+             *      exposure — but a NEW isolated or first-use position allocates collateral
              *      through the same gate this field measures, so size those from this field.
              *
              *      Note the two `margin_*` fields answer opposite questions:
@@ -5445,9 +5643,21 @@ export interface components {
             /** Format: uint32 */
             pageSize?: number | null;
         };
+        GetMarginAccountPnlResponse: {
+            marginAccountId?: string | null;
+            /**
+             * @description Decimal string: settled on the account plus still held in its open risk
+             *      buckets.
+             */
+            realizedPnl?: string | null;
+            /**
+             * @description Decimal string: the account's open positions repriced at the latest risk
+             *      marks.
+             */
+            unrealizedPnl?: string | null;
+        };
         GetMarginAccountSummaryResponse: {
             marginAccountId?: string | null;
-            accountState?: string | null;
             equity?: string | null;
             initialMarginRequired?: string | null;
             maintenanceMarginRequired?: string | null;
@@ -5456,23 +5666,23 @@ export interface components {
              * @description The largest amount a transfer-out of this scope will actually accept.
              *
              *      NOT a clamped `free_collateral`. Free collateral is equity headroom, and
-             *      equity includes realized PnL, accrued funding and mark-to-market gains
-             *      that are not principal a transfer can move — so the two can differ
-             *      without limit. An unrealized gain never counts toward this figure.
+             *      equity includes mark-to-market gains that a transfer cannot move — so
+             *      the two can differ without limit. An unrealized gain never counts toward
+             *      this figure.
              *
-             *      For a risk bucket this is capped by the bucket's allocated collateral;
-             *      for a parent margin account, by deposited collateral that no risk bucket
-             *      has earmarked.
+             *      For a risk bucket this is the bucket's allocated collateral plus its
+             *      realized PnL, less what its positions and resting orders require (the
+             *      bucket's allocation may go negative, which is how realized profit leaves
+             *      a live bucket); for a parent margin account, net deposits plus settled
+             *      realized PnL that no risk bucket has allocated.
              *
-             *      This is the largest accepted transfer-out, NOT a promise that every
-             *      smaller one is accepted. Acceptance is not monotone in the amount: a risk
-             *      bucket whose realized loss exceeds its remaining value accepts the full
-             *      close-out reported here — which settles that loss to the parent margin
-             *      account — while refusing a partial withdrawal that would leave the bucket
-             *      holding less collateral than the loss it has already taken. For such a
-             *      bucket the accepted amounts are everything up to its equity, plus this
-             *      figure itself, with a gap in between. Size a transfer directly from this
-             *      field rather than shaving a margin off it.
+             *      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` (under
+             *      liquidation or frozen as bad debt), whose allocation cannot be released,
+             *      and on a risk bucket whose realized loss has used up its allocation: that
+             *      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.
              */
             withdrawableCollateral?: string | null;
             totalPositionNotional?: string | null;
@@ -5507,6 +5717,16 @@ export interface components {
             copyFollowId?: string | null;
             /** @description On a copy risk bucket row, the followed leader's custom TraderCode handle, when they still hold one */
             copyLeaderHandle?: string | null;
+            /**
+             * @description The risk bucket's lifecycle state. Present only for risk-bucket rows;
+             *      a parent margin account has no lifecycle of its own. Values: NORMAL,
+             *      PENDING_LIQUIDATION, LIQUIDATING, BAD_DEBT, CLOSED.
+             */
+            riskBucketState?: string | null;
+            /** @description See `MarginAccountSummary.subaccount_key`. */
+            subaccountKey?: string | null;
+            /** @description See `MarginAccountSummary.margin_account_state`. */
+            marginAccountState?: string | null;
         };
         GetMarkPriceResponse: {
             /** Format: uuid */
@@ -5703,7 +5923,7 @@ export interface components {
         };
         GetMyReferralPositionResponse: {
             /**
-             * @description Public wallet address of the caller's direct (L1) referrer — who referred them. Empty when the caller was not referred. Never exposes L2/L3 upline or any internal id.
+             * @description Public wallet address of the caller's direct (L1) referrer — who referred them. Empty when the caller was not referred. The same wallet as the first `upline` entry; never an internal id.
              * @example 0x0000000000000000000000000000000000000002
              */
             referrer?: string | null;
@@ -5719,6 +5939,21 @@ 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. */
+            upline?: components["schemas"]["ReferralUplineEntry"][] | null;
+        };
+        GetMyReferralTreeResponse: {
+            /** @description Wallet address whose referees `nodes` lists — the caller's own wallet when the request omitted `parent`. */
+            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.
+             */
+            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. */
+            nodes?: components["schemas"]["ReferralTreeNode"][] | null;
+            /** @description Cursor for the next page; empty when there are no more. */
+            nextPageToken?: string | null;
         };
         /** @description Latest public open interest for a trading pair. */
         GetOpenInterestResponse: {
@@ -5956,7 +6191,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, or SYSTEM
+             * @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.
              * @example REDUCE_ONLY_EXHAUSTED
              */
             terminalReason?: string | null;
@@ -6141,6 +6376,18 @@ export interface components {
             total?: components["schemas"]["PortfolioMarginTotal"];
             positions?: components["schemas"]["PortfolioMarginPositionCounts"];
             riskBuckets?: components["schemas"]["PortfolioRiskBucket"][] | null;
+            /**
+             * @description The margin account `total`, `positions` and `risk_buckets` describe;
+             *      absent when the caller has no margin account yet.
+             */
+            marginAccountId?: string | null;
+            /**
+             * @description With `include_accounts`: every open margin account of the caller, the
+             *      default one first, then sub-accounts by key.
+             */
+            accounts?: components["schemas"]["PortfolioMarginAccount"][] | null;
+            /** @description With `include_accounts`: the sum of `accounts`' totals. */
+            ownerTotal?: components["schemas"]["PortfolioMarginTotal"] | null;
         };
         GetPortfolioPerformanceResponse: {
             window?: components["schemas"]["PortfolioSeriesWindow"];
@@ -6394,7 +6641,7 @@ export interface components {
             cumFees?: string | null;
             /**
              * Format: int64
-             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. Ranked live frames include fills that leave a position open, direct isolated-position margin adds/reductions, and copy-position margin adds; the copy add refreshes its isolated child and copy-cross siblings at the same version. Cross-risk-bucket ALLOCATE/RELEASE and copy follow/stop refreshes use margin_added/margin_reduced but omit the version because those commands write no position rows. Funding omits it because it re-reads live state after sequencing; terminal frames omit it because they report size 0 and sometimes LIQUIDATED while the stored row keeps its size and records CLOSED. Wallet IN/OUT and plain isolated allocation send no position frame. Transfer frames use captured post-command state and are released only after durable acknowledgement. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, persists the account's snapshot and restamps the positions it changed), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. The version advances exactly when the row's versioned content changed at that sequence, a change undone within one persistence batch included; a position a command left unchanged keeps its version, so a RANKED live frame for an untouched sibling of a filled position can carry a higher version than the persisted row while describing identical content — rank it as newer, and nothing changes. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
+             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. Ranked live frames include fills, non-zero funding settlements, terminal closes/liquidations/ADL, direct isolated-position margin adds/reductions, and copy-position margin adds; each uses captured post-command state, and terminal frames retain the stored size and exact CLOSED/LIQUIDATED classification. After restart, a terminal frame rebuilt from legacy reduction history omits the version when that history lacks the margin fields needed to reconstruct complete lifetime allocated margin. Cross-risk-bucket ALLOCATE/RELEASE and copy follow/stop refreshes use margin_added/margin_reduced but omit the version because those commands write no position rows. Wallet IN/OUT and plain isolated allocation send no position frame. Transfer and funding frames use captured post-command state and are released only after durable acknowledgement. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, persists the account's snapshot and restamps the positions it changed), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. The version advances exactly when the row's versioned content changed at that sequence, a change undone within one persistence batch included; a position a command left unchanged keeps its version, so a RANKED live frame for an untouched sibling of a filled position can carry a higher version than the persisted row while describing identical content — rank it as newer, and nothing changes. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
              * @example 918342
              */
             version?: number | null;
@@ -7461,7 +7708,6 @@ export interface components {
         MarginAccountSummary: {
             /** @description Parent margin account UUID. */
             marginAccountId?: string | null;
-            accountState?: string | null;
             equity?: string | null;
             initialMarginRequired?: string | null;
             maintenanceMarginRequired?: string | null;
@@ -7470,23 +7716,23 @@ export interface components {
              * @description The largest amount a transfer-out of this scope will actually accept.
              *
              *      NOT a clamped `free_collateral`. Free collateral is equity headroom, and
-             *      equity includes realized PnL, accrued funding and mark-to-market gains
-             *      that are not principal a transfer can move — so the two can differ
-             *      without limit. An unrealized gain never counts toward this figure.
+             *      equity includes mark-to-market gains that a transfer cannot move — so
+             *      the two can differ without limit. An unrealized gain never counts toward
+             *      this figure.
              *
-             *      For a risk bucket this is capped by the bucket's allocated collateral;
-             *      for a parent margin account, by deposited collateral that no risk bucket
-             *      has earmarked.
+             *      For a risk bucket this is the bucket's allocated collateral plus its
+             *      realized PnL, less what its positions and resting orders require (the
+             *      bucket's allocation may go negative, which is how realized profit leaves
+             *      a live bucket); for a parent margin account, net deposits plus settled
+             *      realized PnL that no risk bucket has allocated.
              *
-             *      This is the largest accepted transfer-out, NOT a promise that every
-             *      smaller one is accepted. Acceptance is not monotone in the amount: a risk
-             *      bucket whose realized loss exceeds its remaining value accepts the full
-             *      close-out reported here — which settles that loss to the parent margin
-             *      account — while refusing a partial withdrawal that would leave the bucket
-             *      holding less collateral than the loss it has already taken. For such a
-             *      bucket the accepted amounts are everything up to its equity, plus this
-             *      figure itself, with a gap in between. Size a transfer directly from this
-             *      field rather than shaving a margin off it.
+             *      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` (under
+             *      liquidation or frozen as bad debt), whose allocation cannot be released,
+             *      and on a risk bucket whose realized loss has used up its allocation: that
+             *      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.
              */
             withdrawableCollateral?: string | null;
             totalPositionNotional?: string | null;
@@ -7552,6 +7798,22 @@ export interface components {
             copyFollowId?: string | null;
             /** @description On a copy risk bucket row, the followed leader's custom TraderCode handle, when they still hold one */
             copyLeaderHandle?: string | null;
+            /**
+             * @description The risk bucket's lifecycle state. Present only for risk-bucket rows;
+             *      a parent margin account has no lifecycle of its own. Values: NORMAL,
+             *      PENDING_LIQUIDATION, LIQUIDATING, BAD_DEBT, CLOSED.
+             */
+            riskBucketState?: string | null;
+            /**
+             * @description The margin account's sub-account key; `default` is the default margin
+             *      account.
+             */
+            subaccountKey?: string | null;
+            /**
+             * @description The margin account's state. Values: ACTIVE, CLOSED (a closed
+             *      sub-account).
+             */
+            marginAccountState?: string | null;
         };
         MatchResult: {
             /**
@@ -7872,6 +8134,17 @@ export interface components {
              */
             positions?: string | null;
         };
+        /** @description One of the caller's open margin accounts in the owner rollup. */
+        PortfolioMarginAccount: {
+            marginAccountId?: string | null;
+            /** @description `default` for the default margin account, else the sub-account's key. */
+            subaccountKey?: string | null;
+            /**
+             * @description The account's totals. `withdrawable_collateral` here is the persisted
+             *      reconstruction of the engine's bound.
+             */
+            total?: components["schemas"]["PortfolioMarginTotal"] | null;
+        };
         PortfolioMarginPositionCounts: {
             total?: string | null;
             cross?: string | null;
@@ -7889,18 +8162,17 @@ export interface components {
              *      the bound the engine enforces on transfers-out and withdrawals, and
              *      therefore also the effective ceiling on funding new isolated or
              *      first-use order capacity, because allocating collateral to a risk
-             *      bucket passes through the same principal-gated door.
+             *      bucket passes through the same capacity-gated door.
              *
              *      NOT a clamped `parent_available_collateral`. That field is
-             *      `free_collateral`, an equity figure: it credits settled realized PnL,
-             *      accrued funding, and mark-to-market gains that a transfer-out cannot
-             *      move, so the two can differ without limit. This bound never credits an
-             *      unrealized gain. Under the default capacity basis it also excludes
-             *      non-principal balances such as banked realized PnL:
-             *      `min(deposited principal - bucket allocations,
-             *      free_collateral - max(unrealized_pnl, 0))`, floored at zero. Whatever
-             *      the engine's configured capacity basis, this is the bound its gates
-             *      actually enforce. It agrees with
+             *      `free_collateral`, an equity figure: it credits mark-to-market gains
+             *      and realized PnL still held in open risk buckets, which a transfer-out
+             *      of the parent cannot move, so the two can differ without limit. This bound never credits an
+             *      unrealized gain. It counts net deposits plus the account's settled
+             *      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.
@@ -7954,14 +8226,15 @@ export interface components {
              *      accept — the bound enforced on bucket collateral withdrawals.
              *
              *      NOT a clamped `free_collateral`: free collateral is equity headroom and
-             *      credits realized PnL and mark-to-market gains that a transfer-out cannot
-             *      move. This bound is capped by the bucket's settled capacity (its
-             *      allocated collateral, under the default capacity basis), and an
-             *      unrealized gain never raises it.
+             *      credits mark-to-market gains that a transfer-out cannot move. This bound
+             *      is the bucket's allocated collateral plus its realized PnL, less funding
+             *      paid, unrealized losses and the margin its positions and resting orders
+             *      require. Realized profit can leave a live bucket this way (the bucket's
+             *      allocation may go negative); an unrealized gain never raises it.
              *
-             *      This is the largest accepted transfer-out, NOT a promise that every
-             *      smaller one is accepted: an underwater flat bucket accepts its full
-             *      close-out while refusing partial withdrawals below it. Agrees with the
+             *      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).
@@ -8211,7 +8484,7 @@ export interface components {
             cumFees?: string | null;
             /**
              * Format: int64
-             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: it means the row predates this field or came from a producer that does not stamp it, so treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. Ranked live frames include fills that leave a position open, direct isolated-position margin adds/reductions, and copy-position margin adds; the copy add refreshes its isolated child and copy-cross siblings at the same version. Cross-risk-bucket ALLOCATE/RELEASE and copy follow/stop refreshes use margin_added/margin_reduced but omit the version because those commands write no position rows. Funding omits it because it re-reads live state after sequencing; terminal frames omit it because they report size 0 and sometimes LIQUIDATED while the stored row keeps its size and records CLOSED. Wallet IN/OUT and plain isolated allocation send no position frame. Transfer frames use captured post-command state and are released only after durable acknowledgement. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, persists the account's snapshot and restamps the positions it changed), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. The version advances exactly when the row's versioned content changed at that sequence, a change undone within one persistence batch included; a position a command left unchanged keeps its version, so a RANKED live frame for an untouched sibling of a filled position can carry a higher version than the persisted row while describing identical content — rank it as newer, and nothing changes. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
+             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: it means the row predates this field or came from a producer that does not stamp it, so treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. Ranked live frames include fills, non-zero funding settlements, terminal closes/liquidations/ADL, direct isolated-position margin adds/reductions, and copy-position margin adds; each uses captured post-command state, and terminal frames retain the stored size and exact CLOSED/LIQUIDATED classification. After restart, a terminal frame rebuilt from legacy reduction history omits the version when that history lacks the margin fields needed to reconstruct complete lifetime allocated margin. Cross-risk-bucket ALLOCATE/RELEASE and copy follow/stop refreshes use margin_added/margin_reduced but omit the version because those commands write no position rows. Wallet IN/OUT and plain isolated allocation send no position frame. Transfer and funding frames use captured post-command state and are released only after durable acknowledgement. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, persists the account's snapshot and restamps the positions it changed), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. The version advances exactly when the row's versioned content changed at that sequence, a change undone within one persistence batch included; a position a command left unchanged keeps its version, so a RANKED live frame for an untouched sibling of a filled position can carry a higher version than the persisted row while describing identical content — rank it as newer, and nothing changes. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
              * @example 918342
              */
             version?: number | null;
@@ -8619,6 +8892,50 @@ export interface components {
              */
             sourceDisplay?: string | null;
         };
+        /** @description One wallet in the caller's referral tree. */
+        ReferralTreeNode: {
+            /**
+             * @description Public wallet address of this referee. Never an internal id.
+             * @example 0x0000000000000000000000000000000000000004
+             */
+            wallet?: string | null;
+            /** @description Human-facing name for this referee: their custom TraderCode handle when they have claimed one, otherwise the wallet address (same as `wallet`). Render this instead of raw hex. */
+            display?: string | null;
+            /**
+             * Format: int32
+             * @description Depth below the caller: 1 (the caller referred this wallet), 2, or 3.
+             */
+            level?: number | null;
+            /** @description Wallet address of the referrer of this node — the caller for a level-1 node. */
+            parent?: string | null;
+            /**
+             * Format: date-time
+             * @description RFC 3339 time this wallet signed up under its parent.
+             */
+            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.
+             */
+            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. */
+            totalEarned?: string | null;
+        };
+        /** @description One ancestor in the caller's referral chain. */
+        ReferralUplineEntry: {
+            /**
+             * @description Public wallet address of the ancestor. Never an internal id.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            wallet?: string | null;
+            /** @description Human-facing name for the ancestor: their custom TraderCode handle when they have claimed one, otherwise the wallet address (same as `wallet`). Render this instead of raw hex. */
+            display?: string | null;
+            /**
+             * Format: int32
+             * @description How far above the caller this ancestor is: 1 (the caller's direct referrer), 2, or 3.
+             */
+            level?: number | null;
+        };
         RefreshManagedMarketQuotesRequest: {
             launchId?: string | null;
             ownerId?: string | null;
@@ -9278,6 +9595,12 @@ export interface components {
              * @description MARKET only: client slippage tolerance in basis points, 0..1000, the same rule placement enforces — a LIMIT or IOC preview carrying it is rejected. Tightens the previewed walk to the band the real order will run under and never widens it; omit for the placement default.
              */
             slippageToleranceBps?: number | null;
+            /**
+             * @description The margin account the preview runs against: the default margin account
+             *      (the default) or any of the caller's open sub-accounts, previewing that
+             *      account's own risk buckets.
+             */
+            marginAccountId?: string | null;
         };
         StopFollowResponse: {
             /**
@@ -9753,6 +10076,25 @@ export interface components {
             asset?: string | null;
             amount?: string | null;
         };
+        TransferCollateralRequest: {
+            /** @description Collateral asset symbol or address. */
+            asset?: string | null;
+            amount?: string | null;
+            /** @description Where the collateral comes from. */
+            from?: components["schemas"]["CollateralTransferEndpoint"] | null;
+            /** @description Where the collateral goes. */
+            to?: components["schemas"]["CollateralTransferEndpoint"] | null;
+        };
+        TransferCollateralResponse: {
+            movementId?: string | null;
+            amount?: string | null;
+            /** @description The source margin account, when the source is one. */
+            fromMarginAccountId?: string | null;
+            /** @description The destination margin account, when the destination is one. */
+            toMarginAccountId?: string | null;
+            /** @description The destination risk bucket, when the destination is one. */
+            toRiskBucketId?: string | null;
+        };
         TransferCollateralToMarginAccountRequest: {
             /** @description Parent margin account UUID that receives collateral. */
             marginAccountId?: string | null;
@@ -9857,6 +10199,13 @@ export interface components {
              *      row is stale (close/reopen race).
              */
             applyToPositionMargin?: boolean | null;
+            /**
+             * @description The margin account whose risk bucket is funded: the default margin
+             *      account (the default) or any of the caller's open sub-accounts, which
+             *      fund their own risk buckets from their own collateral. A copy-trading
+             *      sub-account's buckets belong to its follow and are refused.
+             */
+            marginAccountId?: string | null;
         };
         TransferRewardsRequest: {
             /**
@@ -10147,21 +10496,21 @@ export interface components {
              */
             name?: string | null;
             /**
-             * @description Optional delegation expiry timestamp (ISO 8601). Ends delegated reads, trading, and session refresh. Omit for no delegation expiry; session expiry still applies.
+             * @description Delegation expiry timestamp (ISO 8601). Ends delegated reads, trading, and session refresh. Omit for the default of 14 days from now; at most 180 days ahead.
              * @example 2026-12-31T23:59:59Z
              */
             expiresAt?: string | null;
             /**
-             * @description Required JSON array of actions the agent may perform: CREATE_ORDER, CANCEL_ORDER, REPLACE_ORDER. An empty array permits no actions.
+             * @description Required JSON array of actions the agent may perform: CREATE_ORDER, CANCEL_ORDER, REPLACE_ORDER, READ, MANAGE_RISK_BUCKETS. Every delegated session may read the owner's data; a policy listing only READ, or no action, is a read-only key. MANAGE_RISK_BUCKETS lets the agent move a margin account's free collateral into that account's own risk buckets (POST /api/v1/margin/risk-buckets/collateral/transfer-in), only for an account listed in allowedMarginAccountIds and, if the policy lists markets, only into an isolated risk bucket on a listed market. No action lets an agent move collateral any other way. Any other value is rejected.
              * @example [
              *       "CREATE_ORDER",
              *       "CANCEL_ORDER"
              *     ]
              */
             allowedActions: string[];
-            /** @description Required JSON array of trading pair UUIDs. An order is allowed if its market or its margin account is permitted. Send [] for account-only scope; both scopes empty permit no orders. */
+            /** @description Required JSON array of trading pair UUIDs. Each listed scope must match: with markets and margin accounts both listed, an order needs a listed market AND a listed account. Send [] for account-only scope; both scopes empty permit no orders. */
             allowedTradingPairIds: string[];
-            /** @description Optional JSON array of additional margin account UUIDs. Omitted, null, or [] adds no account scope; it does not grant access to every account. An order is allowed if its market or its margin account is permitted. */
+            /** @description Optional JSON array of margin account UUIDs the agent is bound to. When listed, an order must be on one of these accounts (and on a listed market, if any are listed). Omitted, null, or [] leaves the account unrestricted; both scopes empty permit no orders. */
             allowedMarginAccountIds?: string[] | null;
             /**
              * @description Optional JSON array of permitted order types (LIMIT, MARKET). Omitted, null, or [] means unrestricted order types.
@@ -10192,6 +10541,13 @@ export interface components {
              * @description Unsupported legacy field. Requests that set maxOpenOrders are rejected; no concurrent open-order cap is enforced. Omit this field.
              */
             maxOpenOrders?: number | null;
+            /**
+             * @description Optional JSON array of up to 20 IP addresses or CIDR ranges the agent may create its delegated session from. Omitted, null, or [] allows any address.
+             * @example [
+             *       "203.0.113.0/24"
+             *     ]
+             */
+            ipAllowlist?: string[] | null;
         };
         UpsertFollowRequest: {
             /**
@@ -10808,7 +11164,19 @@ export interface operations {
     };
     get_portfolio_margin: {
         parameters: {
-            query?: never;
+            query?: {
+                /**
+                 * @description One of the caller's margin accounts (the default one or a sub-account) to
+                 *      describe instead of the default one: `total`, `positions` and
+                 *      `risk_buckets` are then that account's own.
+                 */
+                marginAccountId?: string;
+                /**
+                 * @description Also return `accounts`, one row per open margin account of the caller,
+                 *      and `owner_total`, their sum: the owner rollup across sub-accounts.
+                 */
+                includeAccounts?: boolean;
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -11170,6 +11538,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Settings write rate limit exceeded — the lead trader profile, follow create/edit and self-trade-prevention default share a per-account budget (and the budget the account family shares); retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -12274,7 +12649,7 @@ export interface operations {
                 page?: number;
                 /** @description Items per page (max 100) */
                 pageSize?: number;
-                /** @description Only return BuilderCodes payouts of this payout kind: REVENUE_SHARE (the frontend's share of Monaco's fee) or BUILDER_FEE (reserved and not currently emitted). Omit for every kind. */
+                /** @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";
             };
             header?: never;
@@ -12468,6 +12843,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Movement rate limit exceeded — withdrawals, collateral transfers and reward transfers share a per-user budget; refused before the claim reaches the sequencer, so nothing committed; retry after the interval in details.retryAfter (gRPC: RESOURCE_EXHAUSTED) */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -12597,6 +12979,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Settings write rate limit exceeded — the lead trader profile, follow create/edit and self-trade-prevention default share a per-account budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -12992,7 +13381,7 @@ export interface operations {
                     "application/json": components["schemas"]["AddFollowPositionMarginResponse"];
                 };
             };
-            /** @description Invalid follow id, trading pair or amount, or refused by the engine with code COPY_TRADING_REJECTED (no copy position on the pair, the position or the margin account is being liquidated, the position has lost more than its margin, more than the copy account holds; the message names the rule) */
+            /** @description Invalid follow id, trading pair or amount, or refused with code COPY_TRADING_REJECTED (no isolated copy position on the pair, the copy position is being liquidated or is in bad debt, or more than the copy account can put in; the message names the rule) */
             400: {
                 headers: {
                     [name: string]: unknown;
@@ -13020,7 +13409,7 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description The follow is stopping or stopped, or code COPY_TRADING_UNAVAILABLE: copy trading is not available on the platform */
+            /** @description The follow is stopping or stopped */
             409: {
                 headers: {
                     [name: string]: unknown;
@@ -13098,6 +13487,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Follow stop rate limit exceeded; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -13258,6 +13654,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Settings write rate limit exceeded — the lead trader profile, follow create/edit and self-trade-prevention default share a per-account budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -14076,6 +14479,10 @@ export interface operations {
                 page?: number;
                 /** @description Items per page (max 100) */
                 pageSize?: number;
+                /**
+                 * @description Keep only risk-bucket rows in this state (see `risk_bucket_state`). A
+                 *      parent margin account row has no state, so any filter excludes it.
+                 */
                 state?: string;
                 /** @description Trading pair identifier (UUID) */
                 tradingPairId?: string;
@@ -14253,6 +14660,39 @@ export interface operations {
             };
         };
     };
+    get_margin_account_pnl: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description One of the caller's margin accounts: the default one or a sub-account.
+                 * @example 2b1a5f9c-0000-4000-8000-000000000001
+                 */
+                marginAccountId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetMarginAccountPnlResponse"];
+                };
+            };
+            /** @description Read rate limit exceeded — every authenticated read draws one request from the account's read budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     simulate_order_risk: {
         parameters: {
             query?: never;
@@ -14319,6 +14759,37 @@ export interface operations {
             };
         };
     };
+    transfer_collateral: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TransferCollateralRequest"];
+            };
+        };
+        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;
+            };
+        };
+    };
     get_parent_margin_account_summary: {
         parameters: {
             query?: {
@@ -14537,6 +15008,71 @@ export interface operations {
             };
         };
     };
+    create_sub_account: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateSubAccountRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateSubAccountResponse"];
+                };
+            };
+            /** @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;
+            };
+        };
+    };
+    close_sub_account: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @example 2b1a5f9c-0000-4000-8000-000000000001 */
+                marginAccountId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CloseSubAccountRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CloseSubAccountResponse"];
+                };
+            };
+            /** @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?: {
@@ -16347,6 +16883,70 @@ export interface operations {
             };
         };
     };
+    get_my_referral_tree: {
+        parameters: {
+            query?: {
+                parent?: string;
+                /** @description Nodes per page (max 200) */
+                pageSize?: number;
+                /**
+                 * @description Opaque cursor from a previous response's `nextPageToken`; omit or send an
+                 *      empty string for the first page. Only valid with the same `parent`.
+                 */
+                pageToken?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetMyReferralTreeResponse"];
+                };
+            };
+            /** @description Invalid `parent` wallet address, `pageSize`, or `pageToken` */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description `parent` is not the caller or one of the caller's own L1/L2 referees */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Read rate limit exceeded — every authenticated read draws one request from the account's read budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     get_rewards_balance: {
         parameters: {
             query?: never;
@@ -16431,6 +17031,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Movement rate limit exceeded — withdrawals, collateral transfers and reward transfers share a per-user budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -16500,6 +17107,13 @@ export interface operations {
                     "application/json": components["schemas"]["BatchCloseAllResponse"];
                 };
             };
+            /** @description Order rate limit exceeded — each call draws one item per open position it closes (at least 1) from the per-account risk-reduction budget it shares with cancels (and the budget the account family shares). Returned when the first 100 closes do not fit; positions past 100 that do not fit are reported per position as RATE_LIMIT_EXCEEDED instead. Retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     list_position_history: {
@@ -16595,6 +17209,13 @@ export interface operations {
                     "application/json": components["schemas"]["ClosePositionResponse"];
                 };
             };
+            /** @description Order rate limit exceeded — each close draws one item from the per-account risk-reduction budget it shares with cancels (and the budget the account family shares); retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     get_position_pnl_history: {