@0xmonaco/types 1.0.69 → 1.0.70

package/dist/wire/schema.d.ts

@@ -878,6 +878,296 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/copy-trading/follows": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List your follows
+         * @description List your follows.
+         *
+         *      Every follow you have made (live and stopped), newest first.
+         */
+        get: operations["list_my_follows"];
+        put?: never;
+        /**
+         * Follow a lead trader or edit a follow
+         * @description Follow a lead trader or edit a follow.
+         *
+         *      Without `followId`, creates a follow: `allocation` moves from your margin
+         *      account into a new copy account for this leader, and from then on the
+         *      leader's fills are mirrored into it. With `followId`, edits that follow
+         *      (it must be yours): the leader comes from the follow, so an edit works even
+         *      after the leader releases their handle, and `leader` may be empty; a
+         *      `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.
+         */
+        post: operations["upsert_follow"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/follows/preview": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Preview copying a lead trader's open positions
+         * @description Preview copying a leader's open positions.
+         *
+         *      What a follow with these terms would open if it set `copyExisting`, as
+         *      totals only: the estimated margin and fees, and how many of the leader's
+         *      positions would and would not be copied. It names no pair, side or
+         *      reason. Read-only; nothing is placed or reserved. The same session rules
+         *      and follow terms rules as following apply, it is refused while copy
+         *      trading is off, and it spends the order-risk preview budget. At most 64
+         *      positions are sized; `truncated` says when more matched.
+         */
+        post: operations["preview_follow"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/follows/{followId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get one of your follows
+         * @description Get one of your follows.
+         *
+         *      The follow plus its most recent skipped mirrors (up to 100, newest
+         *      first). 404 unless the follow is yours.
+         */
+        get: operations["get_follow"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/follows/{followId}/leader-positions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the open positions of a followed lead trader
+         * @description List the open positions of the leader one of your follows copies.
+         *
+         *      The leader comes from the follow, so this works even after the leader
+         *      releases their handle. 404 unless the follow is yours; 403 unless it is
+         *      live (ACTIVE or CLOSE_ONLY).
+         */
+        get: operations["list_follow_leader_positions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/follows/{followId}/stop": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Stop a follow
+         * @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.
+         */
+        post: operations["stop_follow"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/leaders": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List lead traders
+         * @description List lead traders.
+         *
+         *      The public leaderboard: every ACTIVE lead trader with their stats for one
+         *      window, sorted by the chosen metric (highest first; leaders without a
+         *      value for the metric come last). Served from a snapshot refreshed about
+         *      once a minute; `asOf` is its time.
+         */
+        get: operations["list_lead_traders"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/leaders/me": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get your lead trader profile
+         * @description Get your lead trader profile.
+         *
+         *      Your profile, follow summary and stats for every window. 404 when you
+         *      are not a lead trader.
+         */
+        get: operations["get_my_lead_trader"];
+        /**
+         * Register as a lead trader or edit your profile
+         * @description Register as a lead trader or edit your profile.
+         *
+         *      A registration is checked against the platform's eligibility rules:
+         *      account equity, trading history, closed positions, and a claimed custom
+         *      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.
+         */
+        put: operations["upsert_lead_trader"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/leaders/me/followers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List your followers
+         * @description List your current followers.
+         *
+         *      Your live followers (ACTIVE or CLOSE_ONLY), newest first. Each follower
+         *      appears by wallet address and display string.
+         */
+        get: operations["list_my_followers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/leaders/{leader}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a lead trader
+         * @description Get a lead trader's profile.
+         *
+         *      Profile, follow summary and stats for every window. `leader` is the
+         *      custom TraderCode handle. 404 for an unknown or
+         *      suspended leader.
+         */
+        get: operations["get_lead_trader"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/leaders/{leader}/closed-trades": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List a lead trader's closed trades
+         * @description List a lead trader's closed trades.
+         *
+         *      The leader's reducing executions (partial and full closes, liquidations
+         *      and auto-deleveraging), newest first.
+         */
+        get: operations["list_lead_trader_closed_trades"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/copy-trading/leaders/{leader}/positions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List a followed lead trader's open positions
+         * @description List a lead trader's open positions.
+         *
+         *      Visible to the leader's current followers only: the caller must hold a
+         *      live follow (ACTIVE or CLOSE_ONLY) of this leader in the session's
+         *      application. The leader is addressed by handle; a released handle names
+         *      no one (another user may claim it), so it is a 404 even for a current
+         *      follower.
+         */
+        get: operations["list_lead_trader_open_positions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/delegated-agents": {
         parameters: {
             query?: never;
@@ -3696,6 +3986,34 @@ export interface components {
             message?: string | null;
             submittedQuantity?: string | null;
         };
+        ClosedTrade: {
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             */
+            tradingPairId?: string | null;
+            /** @description LONG or SHORT; empty on legacy rows */
+            positionSide?: string | null;
+            /**
+             * @description DECREASE, CLOSE, LIQUIDATE or ADL
+             * @example CLOSE
+             */
+            action?: string | null;
+            /** @description Closed size in base units */
+            size?: string | null;
+            /** @description Execution price */
+            exitPrice?: string | null;
+            /** @description Average entry price of the position at the close */
+            entryPrice?: string | null;
+            /** @description Gross realized PnL of the execution, in quote units */
+            realizedPnl?: string | null;
+            /** @description Realized PnL net of the execution's fees and funding, in quote units */
+            netRealizedPnl?: string | null;
+            /** @description Net realized PnL as a percentage of the initial margin released by the execution */
+            realizedRoe?: string | null;
+            /** @description Execution time (RFC 3339) */
+            closedAt?: string | null;
+        };
         ConditionalOrder: {
             conditionalOrderId?: string | null;
             /** Format: uuid */
@@ -3746,6 +4064,27 @@ export interface components {
             /** @description TRAILING_STOP only: when tracking began. Absent while the stop is still waiting for activationPrice (state stays ACTIVE in both phases). */
             trailArmedAt?: string | null;
         };
+        /** @description A follow's market filter. */
+        CopyMarketFilter: {
+            /** @description Trading pair UUIDs to copy (at most 256); empty means every market. */
+            tradingPairIds?: string[] | null;
+        };
+        CopySkip: {
+            /**
+             * Format: uuid
+             * @description Trading pair UUID of the leader fill that was not mirrored
+             */
+            tradingPairId?: string | null;
+            /**
+             * @description Why the mirror was skipped, e.g. INSUFFICIENT_MARGIN, BELOW_MIN, MARKET_STATE, LEVERAGE_MISMATCH
+             * @example INSUFFICIENT_MARGIN
+             */
+            reason?: string | null;
+            /** @description The copy quantity that could not be placed, in base units */
+            requestedQuantity?: string | null;
+            /** @description When the mirror was skipped (RFC 3339) */
+            skippedAt?: string | null;
+        };
         CreateDelegatedSessionRequest: {
             /**
              * Format: uuid
@@ -4184,7 +4523,7 @@ export interface components {
             maxOrderNotional?: string | null;
             /**
              * Format: int32
-             * @description Maximum concurrent open orders, if set
+             * @description Legacy field; no concurrent open-order cap is enforced. New or updated policies leave it unset.
              */
             maxOpenOrders?: number | null;
         };
@@ -4297,6 +4636,72 @@ export interface components {
              */
             takerFeeBps?: string | null;
         };
+        Follow: {
+            /**
+             * Format: uuid
+             * @description The follow's id
+             */
+            followId?: string | null;
+            /** @description The leader followed. */
+            leader?: components["schemas"]["LeadTraderRef"] | null;
+            /**
+             * @description ACTIVE, CLOSE_ONLY (only reductions mirror) or STOPPED
+             * @example ACTIVE
+             */
+            status?: string | null;
+            /** @description FOLLOW, CROSS or ISOLATED */
+            marginModePolicy?: string | null;
+            /** @description PROPORTIONAL or FIXED_MARGIN */
+            sizingMode?: string | null;
+            /** @description Margin per leader order for FIXED_MARGIN, in quote units */
+            sizingParam?: string | null;
+            /** @description FOLLOW or FIXED */
+            leverageMode?: string | null;
+            /** @description Leverage for FIXED */
+            fixedLeverage?: string | null;
+            /** @description Collateral allocated to the follow, in quote units */
+            allocation?: string | null;
+            /** @description Copy stop-loss as a fraction of the allocation */
+            slPct?: string | null;
+            /** @description Whether the follow copied the leader's open positions at creation */
+            copyExisting?: boolean | null;
+            /** @description Trading pair UUIDs copied; empty means every market. */
+            tradingPairIds?: string[] | null;
+            /**
+             * Format: uint32
+             * @description Consecutive mirrors skipped for insufficient margin
+             */
+            consecutiveSkips?: number | null;
+            /**
+             * Format: uuid
+             * @description The copy account's cross risk bucket in your margin account
+             */
+            copyRiskBucketId?: string | null;
+            /** @description When the follow started (RFC 3339) */
+            startedAt?: string | null;
+            /** @description When the follow stopped (RFC 3339) */
+            stoppedAt?: string | null;
+            /** @description FOLLOWER, STOP_LOSS, SKIP_LIMIT, ADMIN or LEADER_SUSPENDED */
+            stopReason?: string | null;
+        };
+        Follower: {
+            /** @description The follower's wallet address (lowercase hex) */
+            walletAddress?: string | null;
+            /** @description The follower's custom TraderCode handle when claimed, else the wallet address */
+            display?: string | null;
+            /**
+             * @description ACTIVE or CLOSE_ONLY
+             * @example ACTIVE
+             */
+            status?: string | null;
+            /**
+             * @description Collateral allocated to the follow, in quote units
+             * @example 1000
+             */
+            allocation?: string | null;
+            /** @description When the follow started (RFC 3339) */
+            startedAt?: string | null;
+        };
         FundingPaymentRecord: {
             /**
              * Format: uuid
@@ -4644,6 +5049,17 @@ export interface components {
              */
             recentRequests?: components["schemas"]["FaucetRequestRecord"][] | null;
         };
+        GetFollowResponse: {
+            /** @description The follow. */
+            follow?: components["schemas"]["Follow"] | null;
+            /** @description Most recent skipped mirrors, newest first (up to 100). */
+            recentSkips?: components["schemas"]["CopySkip"][] | null;
+            /**
+             * @description The copy account's equity at the engine's marks, in quote units: its collateral plus the unrealized PnL of its positions. Absent when the engine could not be read. A balance, not trading PnL
+             * @example 1042.75
+             */
+            copyAccountEquity?: string | null;
+        };
         GetFundingStateResponse: {
             /** Format: uuid */
             tradingPairId?: string | null;
@@ -4682,6 +5098,14 @@ export interface components {
             components?: components["schemas"]["IndexComponent"][] | null;
             updatedAt?: string | null;
         };
+        GetLeadTraderResponse: {
+            /** @description The leader's profile. */
+            profile?: components["schemas"]["LeadTraderProfile"] | null;
+            /** @description Current followers and allocation. */
+            followSummary?: components["schemas"]["LeadTraderFollowSummary"] | null;
+            /** @description Stats for 7d, 30d, 90d and all, in that order. */
+            stats?: components["schemas"]["LeadTraderStats"][] | null;
+        };
         GetLimitsResponse: {
             limits?: components["schemas"]["SubAccountLimit"][] | null;
         };
@@ -4730,6 +5154,12 @@ export interface components {
             withdrawableCollateral?: string | null;
             totalPositionNotional?: string | null;
             unrealizedPnl?: string | null;
+            /**
+             * @description On a risk bucket row this is the risk bucket's cash balance (realized
+             *      closes, funding and transfers between a copy account's risk buckets land
+             *      here), not trading profit; trading PnL comes from position history and
+             *      the portfolio PnL endpoints.
+             */
             realizedPnl?: string | null;
             updatedAt?: string | null;
             label?: string | null;
@@ -4747,6 +5177,13 @@ export interface components {
              *      rows and persisted-fallback reads.
              */
             availableOrderCollateral?: string | null;
+            /**
+             * Format: uuid
+             * @description On a copy risk bucket row, the id of the follow (copy account) that funds it
+             */
+            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;
         };
         GetMarkPriceResponse: {
             /** Format: uuid */
@@ -4874,7 +5311,7 @@ export interface components {
             movements?: components["schemas"]["LedgerMovement"][] | null;
             /**
              * Format: uint32
-             * @description Total number of movements
+             * @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.
              * @example 150
              */
             total?: number | null;
@@ -4892,7 +5329,7 @@ export interface components {
             pageSize?: number | null;
             /**
              * Format: uint32
-             * @description Total number of pages
+             * @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
              */
             totalPages?: number | null;
@@ -5937,43 +6374,18 @@ export interface components {
         };
         GetUserTradesResponse: {
             trades?: components["schemas"]["UserTrade"][] | null;
-            /**
-             * @deprecated
-             * @description Deprecated: current page number (legacy offset mode only; 0 in cursor mode)
-             * @example 1
-             */
-            page?: string | null;
             /**
              * @description Items per page
              * @example 20
              */
             pageSize?: string | null;
             /**
-             * @deprecated
-             * @description Deprecated: total matching trades (legacy page-number mode only; 0 in cursor mode). Exact up to pageSize x 10,000 rows and saturates there. Use pageToken cursor pagination instead.
-             * @example 150
-             */
-            total?: string | null;
-            /**
-             * @deprecated
-             * @description Deprecated: total pages at this pageSize (legacy page-number mode only; 0 in cursor mode). Exact up to 10,000 and saturates there. Use pageToken cursor pagination instead.
-             * @example 8
-             */
-            totalPages?: string | null;
-            /**
-             * @description Cursor for the next page. Empty on every page-number (legacy) response —
-             *      page-number mode never mints a token, full page or not, since resuming
-             *      a client from a legacy-minted position could silently strand archived
-             *      history newer than wherever that page happened to end. To walk full
-             *      history, start a cursor-mode request with `page_token` present but
-             *      empty (`""`); from then on the token is present whenever that page
-             *      returned any rows (AIP-158 "maybe more" semantics), not only when the
-             *      page is exactly full. Empty only when a cursor-mode page returned zero
-             *      rows, which is the sole proof the walk is exhausted; a non-empty token
-             *      does not guarantee further results, so keep following it until a
-             *      response returns zero rows and an empty token. The two modes never
-             *      bridge: a page-number response's empty token is not "done," it simply
-             *      means page-number mode does not participate in cursor continuation.
+             * @description Cursor for the next page. Present whenever that page returned any rows
+             *      (AIP-158 "maybe more" semantics), not only when the page is exactly full.
+             *      Empty only when a page returned zero rows, which is the sole proof the
+             *      walk is exhausted; a non-empty token does not guarantee further results,
+             *      so keep following it until a response returns zero rows and an empty
+             *      token.
              */
             nextPageToken?: string | null;
         };
@@ -6006,6 +6418,136 @@ export interface components {
              */
             source?: string | null;
         };
+        /** @description Current followers and the collateral they have allocated. Window-free. */
+        LeadTraderFollowSummary: {
+            /**
+             * Format: uint32
+             * @description Live follows (ACTIVE or CLOSE_ONLY)
+             * @example 12
+             */
+            followerCount?: number | null;
+            /**
+             * @description Collateral allocated by live follows, in quote units (AUM as allocated, not marked)
+             * @example 25000
+             */
+            allocated?: string | null;
+            /**
+             * @description Equity of live follows' copy accounts at the engine's marks, in quote units (AUM marked: collateral plus unrealized PnL of copy positions). Absent when it could not be read. Not trading PnL
+             * @example 25400.5
+             */
+            aumEquity?: string | null;
+        };
+        LeadTraderListing: {
+            /** @description The leader's profile. */
+            profile?: components["schemas"]["LeadTraderProfile"] | null;
+            /** @description Current followers and allocation. */
+            followSummary?: components["schemas"]["LeadTraderFollowSummary"] | null;
+            /** @description Stats for the requested window. */
+            stats?: components["schemas"]["LeadTraderStats"] | null;
+        };
+        LeadTraderOpenPosition: {
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             */
+            tradingPairId?: string | null;
+            /** @description LONG or SHORT */
+            side?: string | null;
+            /** @description Position size in base units */
+            size?: string | null;
+            /** @description Average entry price */
+            entryPrice?: string | null;
+            /** @description Current mark price */
+            markPrice?: string | null;
+            /** @description Unrealized PnL at the mark, in quote units */
+            unrealizedPnl?: string | null;
+            /** @description Position leverage */
+            leverage?: string | null;
+            /** @description CROSS or ISOLATED */
+            marginMode?: string | null;
+        };
+        LeadTraderProfile: {
+            /** @description Who the leader is. */
+            leader?: components["schemas"]["LeadTraderRef"] | null;
+            /**
+             * @description ACTIVE (accepting follows), PAUSED (existing follows keep mirroring, no new follows) or SUSPENDED (only on your own profile)
+             * @example ACTIVE
+             */
+            status?: string | null;
+            /**
+             * Format: uint32
+             * @description The leader's share of followers' realized profit, in basis points
+             * @example 1000
+             */
+            shareBps?: number | null;
+            /** @description Free-text profile description; empty when none */
+            bio?: string | null;
+            /**
+             * @description The leader's minimum follow allocation in quote units, when above the platform floor
+             * @example 1000
+             */
+            minAllocation?: string | null;
+            /**
+             * @description Registration time (RFC 3339)
+             * @example 2026-09-23T12:00:00Z
+             */
+            registeredAt?: string | null;
+        };
+        /** @description A lead trader as the public sees them: never an internal id. */
+        LeadTraderRef: {
+            /**
+             * @description The leader's wallet address (lowercase hex)
+             * @example 0x1234567890abcdef1234567890abcdef12345678
+             */
+            walletAddress?: string | null;
+            /**
+             * @description The leader's custom TraderCode handle, when claimed
+             * @example alpha_trader
+             */
+            handle?: string | null;
+            /**
+             * @description The handle when claimed, else the wallet address (every listed or addressable leader has a handle)
+             * @example alpha_trader
+             */
+            display?: string | null;
+        };
+        /**
+         * @description A leader's trading performance over one window, from the account PnL
+         *      rollups. Bucket balances never feed these numbers.
+         */
+        LeadTraderStats: {
+            /**
+             * @description 7d, 30d, 90d or all
+             * @example 30d
+             */
+            window?: string | null;
+            /**
+             * @description Trading PnL over the window in quote units: realized plus unrealized, net of fees and funding
+             * @example 1250.5
+             */
+            pnl?: string | null;
+            /**
+             * @description PnL as a percentage of the highest base balance (starting equity plus net deposits) over the window; absent when that base is not positive
+             * @example 12.5
+             */
+            roiPct?: string | null;
+            /**
+             * @description Largest peak-to-trough fall of cumulative PnL over the window, as a percentage of the highest base balance; sampled at the window's rollup interval (1h for 7d, 4h for 30d and 90d, 1d for all)
+             * @example 4.2
+             */
+            maxDrawdownPct?: string | null;
+            /**
+             * @description Winning closes as a percentage of winning plus losing closes over the window; absent when there were none
+             * @example 61.5
+             */
+            winRatePct?: string | null;
+            /**
+             * Format: uint32
+             * @description Closes over the window, break-even included
+             * @example 40
+             */
+            closedTrades?: number | null;
+        };
         LedgerMovement: {
             /**
              * Format: uuid
@@ -6283,23 +6825,17 @@ export interface components {
             orders?: components["schemas"]["ConditionalOrder"][] | null;
             /**
              * Format: uint32
-             * @description Matching conditional orders in page-number (offset) mode: exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so a caller with more matching conditional orders than the listing can page through reads the cap, not its lifetime total. 0 in cursor (pageToken) mode, which runs no COUNT (AIP-158).
+             * @description Matching conditional orders, counted up to a server ceiling of 10,000 and saturating there, so a caller with more than that reads the cap rather than a lifetime total.
              * @example 3
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @deprecated
-             * @description Deprecated: current page number (legacy offset mode only; 0 in cursor mode)
-             */
-            page?: number | null;
             /** Format: uint32 */
             pageSize?: number | null;
             /**
              * @description Cursor for the next page, minted only when a further page exists — the
              *      read over-fetches one row to decide, so there is no "maybe more" state.
-             *      Empty on every page-number (legacy) response, and empty on the final
-             *      cursor page (including a full final page, since nothing follows it).
+             *      Empty on the final page (including a full final page, since nothing
+             *      follows it).
              *      Follow it until it comes back empty; that empty token is the definitive
              *      end of the walk, so no extra zero-row request is needed. Do not feed the
              *      empty token back as `page_token` — an empty input `page_token` restarts
@@ -6315,6 +6851,9 @@ export interface components {
             /** @description The calling owner's delegated agents */
             agents?: components["schemas"]["DelegatedAgent"][] | null;
         };
+        ListFollowLeaderPositionsResponse: {
+            positions?: components["schemas"]["LeadTraderOpenPosition"][] | null;
+        };
         ListFundingHistoryResponse: {
             records?: components["schemas"]["FundingRecord"][] | null;
             /** Format: uint32 */
@@ -6328,7 +6867,7 @@ export interface components {
             records?: components["schemas"]["FundingPaymentRecord"][] | null;
             /**
              * Format: uint32
-             * @description Total matching funding payment records
+             * @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.
              * @example 2
              */
             total?: number | null;
@@ -6346,11 +6885,26 @@ export interface components {
             pageSize?: number | null;
             /**
              * Format: uint32
-             * @description Total number of pages
+             * @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 1
              */
             totalPages?: number | null;
         };
+        ListLeadTraderClosedTradesResponse: {
+            closedTrades?: components["schemas"]["ClosedTrade"][] | null;
+            /** @description Cursor for the next page; empty when there are no more. */
+            nextPageToken?: string | null;
+        };
+        ListLeadTraderOpenPositionsResponse: {
+            positions?: components["schemas"]["LeadTraderOpenPosition"][] | null;
+        };
+        ListLeadTradersResponse: {
+            leaders?: components["schemas"]["LeadTraderListing"][] | null;
+            /** @description Cursor for the next page; empty when there are no more. */
+            nextPageToken?: string | null;
+            /** @description Time of the leaderboard snapshot these rows come from (RFC 3339) */
+            asOf?: string | null;
+        };
         ListManagedMarketAssignmentsResponse: {
             /** @description Expected assignments, including phases currently unable to quote. */
             items?: components["schemas"]["ManagedMarketAssignment"][] | null;
@@ -6371,6 +6925,16 @@ export interface components {
             /** Format: uint32 */
             pageSize?: number | null;
         };
+        ListMyFollowersResponse: {
+            followers?: components["schemas"]["Follower"][] | null;
+            /** @description Cursor for the next page; empty when there are no more. */
+            nextPageToken?: string | null;
+        };
+        ListMyFollowsResponse: {
+            follows?: components["schemas"]["Follow"][] | null;
+            /** @description Cursor for the next page; empty when there are no more. */
+            nextPageToken?: string | null;
+        };
         ListOrdersResponse: {
             orders?: components["schemas"]["GetOrderResponse"][] | null;
             /**
@@ -6379,13 +6943,6 @@ export interface components {
              * @example 150
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @deprecated
-             * @description Deprecated: current page number (legacy offset mode only; 0 in cursor mode)
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -6399,19 +6956,12 @@ export interface components {
              */
             totalPages?: number | null;
             /**
-             * @description Cursor for the next page. Empty on every page-number (legacy) response —
-             *      page-number mode never mints a token, full page or not, since resuming
-             *      a client from a legacy-minted position could silently strand archived
-             *      history newer than wherever that page happened to end. To walk full
-             *      history, start a cursor-mode request with `page_token` present but
-             *      empty (`""`); from then on the token is present whenever that page
-             *      returned any rows (AIP-158 "maybe more" semantics), not only when the
-             *      page is exactly full. Empty only when a cursor-mode page returned zero
-             *      rows, which is the sole proof the walk is exhausted; a non-empty token
-             *      does not guarantee further results, so keep following it until a
-             *      response returns zero rows and an empty token. The two modes never
-             *      bridge: a page-number response's empty token is not "done," it simply
-             *      means page-number mode does not participate in cursor continuation.
+             * @description Cursor for the next page. Present whenever that page returned any rows
+             *      (AIP-158 "maybe more" semantics), not only when the page is exactly full.
+             *      Empty only when a page returned zero rows, which is the sole proof the
+             *      walk is exhausted; a non-empty token does not guarantee further results,
+             *      so keep following it until a response returns zero rows and an empty
+             *      token.
              */
             nextPageToken?: string | null;
             /**
@@ -6514,17 +7064,10 @@ export interface components {
             orders?: components["schemas"]["TwapOrder"][] | null;
             /**
              * Format: uint32
-             * @description Matching TWAP orders in page-number (offset) mode: exact up to 10,000 pages of the requested page size (page_size x 10,000 rows) and saturates there, so a caller with more matching TWAP orders than the listing can page through reads the cap, not its lifetime total. 0 in cursor (pageToken) mode, which runs no COUNT (AIP-158).
+             * @description Matching TWAP orders, counted up to a server ceiling of 10,000 and saturating there, so a caller with more than that reads the cap rather than a lifetime total.
              * @example 3
              */
             total?: number | null;
-            /**
-             * Format: uint32
-             * @deprecated
-             * @description Deprecated: current page number (legacy offset mode only; 0 in cursor mode)
-             * @example 1
-             */
-            page?: number | null;
             /**
              * Format: uint32
              * @description Items per page
@@ -6534,8 +7077,8 @@ export interface components {
             /**
              * @description Cursor for the next page, minted only when a further page exists — the
              *      read over-fetches one row to decide, so there is no "maybe more" state.
-             *      Empty on every page-number (legacy) response, and empty on the final
-             *      cursor page (including a full final page, since nothing follows it).
+             *      Empty on the final page (including a full final page, since nothing
+             *      follows it).
              *      Follow it until it comes back empty; that empty token is the definitive
              *      end of the walk, so no extra zero-row request is needed. Do not feed the
              *      empty token back as `page_token` — an empty input `page_token` restarts
@@ -6619,6 +7162,12 @@ export interface components {
             withdrawableCollateral?: string | null;
             totalPositionNotional?: string | null;
             unrealizedPnl?: string | null;
+            /**
+             * @description On a risk bucket row this is the risk bucket's cash balance (realized
+             *      closes, funding and transfers between a copy account's risk buckets land
+             *      here), not trading profit; trading PnL comes from position history and
+             *      the portfolio PnL endpoints.
+             */
             realizedPnl?: string | null;
             updatedAt?: string | null;
             label?: string | null;
@@ -6667,6 +7216,13 @@ export interface components {
              *      neither of the gate's terms is reconstructable.
              */
             availableOrderCollateral?: string | null;
+            /**
+             * Format: uuid
+             * @description On a copy risk bucket row, the id of the follow (copy account) that funds it
+             */
+            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;
         };
         MatchResult: {
             /**
@@ -7122,6 +7678,13 @@ export interface components {
              *      against another.
              */
             tradingPairId?: string | null;
+            /**
+             * Format: uuid
+             * @description On a copy risk bucket row, the id of the follow (copy account) that funds it
+             */
+            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;
         };
         PortfolioSeriesWindow: {
             /**
@@ -7398,6 +7961,75 @@ export interface components {
              */
             cumFees?: string | null;
         };
+        PreviewFollowRequest: {
+            /**
+             * @description The leader's custom TraderCode handle
+             * @example alpha_trader
+             */
+            leader?: string | null;
+            /**
+             * @description FOLLOW (default), CROSS or ISOLATED
+             * @example FOLLOW
+             */
+            marginModePolicy?: string | null;
+            /**
+             * @description PROPORTIONAL (default) or FIXED_MARGIN
+             * @example PROPORTIONAL
+             */
+            sizingMode?: string | null;
+            /** @description Margin per leader order in quote units; required for FIXED_MARGIN, omitted otherwise */
+            sizingParam?: string | null;
+            /**
+             * @description FOLLOW (default) or FIXED
+             * @example FOLLOW
+             */
+            leverageMode?: string | null;
+            /** @description Leverage for every copy; required for FIXED, omitted otherwise */
+            fixedLeverage?: string | null;
+            /**
+             * @description Collateral the copy account would start with, in quote units
+             * @example 1000
+             */
+            allocation?: string | null;
+            /** @description Markets to copy; omit to copy every market the leader trades. */
+            markets?: components["schemas"]["CopyMarketFilter"] | null;
+        };
+        /**
+         * @description What following with `copyExisting` would open, as totals only. The caller
+         *      of a preview is never a follower of the leader (copyExisting applies only
+         *      on a create), so the response names no pair, side, size, mark or skip
+         *      reason, and a leader whose positions cannot be copied at all gives
+         *      `copiedPositions = 0` with no reason. The totals are rounded UP to cents
+         *      (the settlement currency's display precision). A residual aggregate signal
+         *      remains: the counts and the rounded totals across varied allocations
+         *      bound the size of the leader's book, never its markets or direction.
+         */
+        PreviewFollowResponse: {
+            /**
+             * @description Estimated collateral the copied positions would reserve at placement, in quote units, rounded up to cents
+             * @example 125.40
+             */
+            estimatedMargin?: string | null;
+            /**
+             * @description Estimated taker fees of the copies, in quote units, rounded up to cents
+             * @example 0.35
+             */
+            estimatedFee?: string | null;
+            /**
+             * Format: uint32
+             * @description The leader's positions (in the copied markets) that would be copied
+             * @example 2
+             */
+            copiedPositions?: number | null;
+            /**
+             * Format: uint32
+             * @description The leader's positions (in the copied markets) that would not be copied
+             * @example 1
+             */
+            skippedPositions?: number | null;
+            /** @description True when the leader holds more positions in the copied markets than one preview sizes (64); the totals and counts cover the first ones only */
+            truncated?: boolean | null;
+        };
         PriceChange: {
             /**
              * @description Price 24 hours ago
@@ -8285,6 +8917,13 @@ export interface components {
              */
             slippageToleranceBps?: number | null;
         };
+        StopFollowResponse: {
+            /**
+             * Format: uuid
+             * @description The stopped follow's id
+             */
+            followId?: string | null;
+        };
         SubAccount: {
             /**
              * Format: uuid
@@ -9139,7 +9778,7 @@ export interface components {
              * @description Agent wallet address (EVM, 42 chars including 0x)
              * @example 0x742d35cc6634c0532925a3b8d4060f31e2c3d8b5
              */
-            agentAddress?: string | null;
+            agentAddress: string;
             /**
              * @description Optional human-friendly label for the agent
              * @example market-maker-bot
@@ -9151,26 +9790,26 @@ export interface components {
              */
             expiresAt?: string | null;
             /**
-             * @description Actions the agent may perform: CREATE_ORDER, CANCEL_ORDER, REPLACE_ORDER
+             * @description Required JSON array of actions the agent may perform: CREATE_ORDER, CANCEL_ORDER, REPLACE_ORDER. An empty array permits no actions.
              * @example [
              *       "CREATE_ORDER",
              *       "CANCEL_ORDER"
              *     ]
              */
-            allowedActions?: string[] | null;
-            /** @description Trading pair UUIDs the agent may trade. An order is allowed if its market or its margin account is permitted. */
-            allowedTradingPairIds?: string[] | null;
-            /** @description Margin account UUIDs the agent may trade against. An order is allowed if its market or its margin account is permitted. */
+            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. */
+            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. */
             allowedMarginAccountIds?: string[] | null;
             /**
-             * @description Permitted order types (LIMIT, MARKET). Empty means unrestricted.
+             * @description Optional JSON array of permitted order types (LIMIT, MARKET). Omitted, null, or [] means unrestricted order types.
              * @example [
              *       "LIMIT"
              *     ]
              */
             allowedOrderTypes?: string[] | null;
             /**
-             * @description Permitted time-in-force values (GTC, IOC, FOK). Empty means unrestricted.
+             * @description Optional JSON array of permitted time-in-force values (GTC, IOC, FOK). Omitted, null, or [] means unrestricted time in force.
              * @example [
              *       "GTC"
              *     ]
@@ -9188,11 +9827,104 @@ export interface components {
             maxOrderNotional?: string | null;
             /**
              * Format: int32
-             * @description Maximum concurrent open orders. Omit for no limit.
-             * @example 100
+             * @description Unsupported legacy field. Requests that set maxOpenOrders are rejected; no concurrent open-order cap is enforced. Omit this field.
              */
             maxOpenOrders?: number | null;
         };
+        UpsertFollowRequest: {
+            /**
+             * Format: uuid
+             * @description Omit to create a follow; set to edit one of your follows
+             */
+            followId?: string | null;
+            /**
+             * @description The leader's custom TraderCode handle; required on a create, optional on an edit (a consistency check when it resolves)
+             * @example alpha_trader
+             */
+            leader?: string | null;
+            /**
+             * @description FOLLOW (default: the leader's risk bucket mode per market), CROSS or ISOLATED
+             * @example FOLLOW
+             */
+            marginModePolicy?: string | null;
+            /**
+             * @description PROPORTIONAL (default: scaled by copy account equity over the leader's equity) or FIXED_MARGIN
+             * @example PROPORTIONAL
+             */
+            sizingMode?: string | null;
+            /** @description Margin per leader order in quote units; required for FIXED_MARGIN, omitted otherwise */
+            sizingParam?: string | null;
+            /**
+             * @description FOLLOW (default: the leader's leverage) or FIXED
+             * @example FOLLOW
+             */
+            leverageMode?: string | null;
+            /** @description Leverage for every copy; required for FIXED, omitted otherwise */
+            fixedLeverage?: string | null;
+            /**
+             * @description Collateral for the copy account, in quote units, at or above the minimum
+             * @example 1000
+             */
+            allocation?: string | null;
+            /**
+             * @description Copy stop-loss as a fraction of the allocation in (0, 1]; omitted means none
+             * @example 0.25
+             */
+            slPct?: string | null;
+            /** @description On a create, also copy the leader's currently open positions into the new copy account, sized like any mirrored fill (PreviewFollow shows the cost). Default false. Refused on an edit */
+            copyExisting?: boolean | null;
+            /** @description Markets to copy; omit to copy every market the leader trades. */
+            markets?: components["schemas"]["CopyMarketFilter"] | null;
+        };
+        UpsertFollowResponse: {
+            /**
+             * Format: uuid
+             * @description The follow's id
+             */
+            followId?: string | null;
+            /**
+             * Format: uuid
+             * @description The copy account: the cross risk bucket in your margin account that holds this follow's collateral and positions
+             */
+            copyRiskBucketId?: string | null;
+            /** @description True when this call created the follow, false when it edited one */
+            created?: boolean | null;
+        };
+        UpsertLeadTraderRequest: {
+            /**
+             * Format: uint32
+             * @description Profit share in basis points, within the platform's range; omitted keeps the current share (the platform default on a registration)
+             * @example 1000
+             */
+            shareBps?: number | null;
+            /** @description Free-text profile description, at most 2,000 bytes; omitted clears it */
+            bio?: string | null;
+            /**
+             * @description ACTIVE (default) or PAUSED
+             * @example ACTIVE
+             */
+            status?: string | null;
+            /**
+             * @description Minimum follow allocation in quote units, at or above the platform floor; omitted clears it
+             * @example 1000
+             */
+            minAllocation?: string | null;
+        };
+        UpsertLeadTraderResponse: {
+            /** @description True when this call registered you, false when it edited your profile */
+            created?: boolean | null;
+            /**
+             * @description Your status after the call
+             * @example ACTIVE
+             */
+            status?: string | null;
+            /**
+             * Format: uint32
+             * @description Your profit share after the call, in basis points
+             * @example 1000
+             */
+            shareBps?: number | null;
+        };
         UserInfo: {
             /**
              * Format: uuid
@@ -10396,31 +11128,20 @@ export interface operations {
     get_user_trades: {
         parameters: {
             query?: {
-                /**
-                 * @deprecated
-                 * @description Deprecated: page number for legacy offset pagination (1-indexed). Use pageToken cursor pagination instead.
-                 */
-                page?: number;
                 /** @description Items per page (max: 100 in page-number mode; up to 1000 when pageToken is present) */
                 pageSize?: number;
                 /** @description Trading pair identifier (UUID) */
                 tradingPairId?: string;
                 /**
-                 * @description Pagination cursor with three distinct states:
-                 *       - Omitted: legacy page-number pagination via `page`, limited to recent
-                 *         history once the archive window is enabled.
-                 *       - Empty string (""): start a cursor walk with no prior position, from
-                 *         the newest row (this endpoint always sorts newest-first).
+                 * @description Pagination cursor with two states:
+                 *       - 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.
                  *
-                 *      In either cursor-walk state (empty or non-empty), `page` is ignored, the
-                 *      response omits exact totals (total/total_pages/page are 0), and results
-                 *      cover full trade history — hot and archived rows merged — unlike
-                 *      page-number mode, which only ever sees recent history. Clients that need
-                 *      complete trade history must use the cursor form (start with an empty
-                 *      string, then follow next_page_token) rather than `page`. Filters must
-                 *      match the request that produced the token.
+                 *      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
+                 *      behind a filter. Filters must match the request that produced the token.
                  */
                 pageToken?: string;
             };
@@ -11272,9 +11993,17 @@ export interface operations {
             };
         };
     };
-    list_delegated_agents: {
+    list_my_follows: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description Items per page (max 1000) */
+                pageSize?: number;
+                /**
+                 * @description Opaque cursor from a previous response's `nextPageToken`; omit for the
+                 *      first page.
+                 */
+                pageToken?: string;
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -11287,18 +12016,18 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ListDelegatedAgentsResponse"];
+                    "application/json": components["schemas"]["ListMyFollowsResponse"];
                 };
             };
-            /** @description Authentication required */
-            401: {
+            /** @description Invalid query parameters or page token */
+            400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Only master accounts can list delegated agents */
-            403: {
+            /** @description Authentication required */
+            401: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -11320,7 +12049,7 @@ export interface operations {
             };
         };
     };
-    upsert_delegated_agent: {
+    upsert_follow: {
         parameters: {
             query?: never;
             header?: never;
@@ -11329,7 +12058,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["UpsertDelegatedAgentRequest"];
+                "application/json": components["schemas"]["UpsertFollowRequest"];
             };
         };
         responses: {
@@ -11339,10 +12068,10 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["DelegatedAgent"];
+                    "application/json": components["schemas"]["UpsertFollowResponse"];
                 };
             };
-            /** @description Invalid request */
+            /** @description Invalid request, or refused by a follow rule (the message names the rule) */
             400: {
                 headers: {
                     [name: string]: unknown;
@@ -11356,56 +12085,36 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Only master accounts can manage delegated agents */
+            /** @description Delegated agent or sub-account sessions cannot follow */
             403: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Internal server error */
-            500: {
+            /** @description Lead trader or follow not found */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-        };
-    };
-    list_delegated_agent_owners: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description OK */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ListDelegatedAgentOwnersResponse"];
-                };
-            };
-            /** @description Authentication required */
-            401: {
+            /** @description Copy trading is not available */
+            409: {
                 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: {
+            /** @description Internal server error */
+            500: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Internal server error */
-            500: {
+            /** @description Matching engine unavailable; retry */
+            503: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -11413,7 +12122,7 @@ export interface operations {
             };
         };
     };
-    create_delegated_session: {
+    preview_follow: {
         parameters: {
             query?: never;
             header?: never;
@@ -11422,7 +12131,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["CreateDelegatedSessionRequest"];
+                "application/json": components["schemas"]["PreviewFollowRequest"];
             };
         };
         responses: {
@@ -11432,10 +12141,10 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["CreateDelegatedSessionResponse"];
+                    "application/json": components["schemas"]["PreviewFollowResponse"];
                 };
             };
-            /** @description Invalid request */
+            /** @description Invalid request, or terms a follow would refuse (the message names the rule) */
             400: {
                 headers: {
                     [name: string]: unknown;
@@ -11449,24 +12158,804 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description No active delegation for owner */
+            /** @description Delegated agent or sub-account sessions cannot follow */
             403: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Internal server error */
-            500: {
+            /** @description Lead trader not found */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-        };
-    };
-    revoke_delegated_agent: {
-        parameters: {
+            /** @description Copy trading is not available */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Read or order-risk preview rate limit exceeded; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Matching engine unavailable or its preview capacity is busy; retry */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_follow: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                followId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetFollowResponse"];
+                };
+            };
+            /** @description Invalid follow id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Follow not found */
+            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;
+            };
+        };
+    };
+    list_follow_leader_positions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                followId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListFollowLeaderPositionsResponse"];
+                };
+            };
+            /** @description Invalid follow id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The follow is stopped */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Follow not found */
+            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;
+            };
+            /** @description Matching engine unavailable; retry */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    stop_follow: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                followId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StopFollowResponse"];
+                };
+            };
+            /** @description Invalid follow id, or refused by the engine (the message names the rule) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Delegated agent sessions cannot stop a follow */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Follow not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Matching engine unavailable; retry */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    list_lead_traders: {
+        parameters: {
+            query?: {
+                /** @description Metric to rank by, highest first */
+                sort?: "roi" | "pnl" | "followers" | "allocated" | "win_rate";
+                /** @description Stats window */
+                window?: "7d" | "30d" | "90d" | "all";
+                /** @description Items per page (max 100) */
+                pageSize?: number;
+                /**
+                 * @description Opaque cursor from a previous response's `nextPageToken`; omit for the
+                 *      first page. Sort and window must match the request that produced it.
+                 */
+                pageToken?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListLeadTradersResponse"];
+                };
+            };
+            /** @description Invalid query parameters or page token */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_my_lead_trader: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetLeadTraderResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description You are not a lead trader */
+            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;
+            };
+        };
+    };
+    upsert_lead_trader: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpsertLeadTraderRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UpsertLeadTraderResponse"];
+                };
+            };
+            /** @description Invalid request, or refused by an eligibility rule such as one lead profile per wallet (the message names the rule) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Delegated agent or sub-account sessions cannot register */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Copy trading is not available */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Matching engine unavailable; retry */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    list_my_followers: {
+        parameters: {
+            query?: {
+                /** @description Items per page (max 1000) */
+                pageSize?: number;
+                /**
+                 * @description Opaque cursor from a previous response's `nextPageToken`; omit for the
+                 *      first page.
+                 */
+                pageToken?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListMyFollowersResponse"];
+                };
+            };
+            /** @description Invalid query parameters or page token */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Read rate limit exceeded — every authenticated read draws one request from the account's read budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_lead_trader: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                leader: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetLeadTraderResponse"];
+                };
+            };
+            /** @description Lead trader not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    list_lead_trader_closed_trades: {
+        parameters: {
+            query?: {
+                /** @description Items per page (max 100) */
+                pageSize?: number;
+                /**
+                 * @description Opaque cursor from a previous response's `nextPageToken`; omit for the
+                 *      first page.
+                 */
+                pageToken?: string;
+            };
+            header?: never;
+            path: {
+                leader: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListLeadTraderClosedTradesResponse"];
+                };
+            };
+            /** @description Invalid query parameters or page token */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Lead trader not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    list_lead_trader_open_positions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                leader: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListLeadTraderOpenPositionsResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Only current followers of this leader can see open positions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Lead trader not found */
+            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;
+            };
+            /** @description Matching engine unavailable; retry */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    list_delegated_agents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListDelegatedAgentsResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Only master accounts can list delegated agents */
+            403: {
+                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;
+            };
+        };
+    };
+    upsert_delegated_agent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpsertDelegatedAgentRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DelegatedAgent"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Only master accounts can manage delegated agents */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    list_delegated_agent_owners: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListDelegatedAgentOwnersResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Read rate limit exceeded — every authenticated read draws one request from the account's read budget; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    create_delegated_session: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateDelegatedSessionRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateDelegatedSessionResponse"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No active delegation for owner */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    revoke_delegated_agent: {
+        parameters: {
             query?: never;
             header?: never;
             path: {
@@ -12845,11 +14334,6 @@ export interface operations {
     get_orders: {
         parameters: {
             query?: {
-                /**
-                 * @deprecated
-                 * @description Deprecated: page number for legacy offset pagination (1-indexed). Use pageToken cursor pagination instead.
-                 */
-                page?: number;
                 /** @description Items per page (max 100 in page-number mode; up to 1000 when pageToken is present) */
                 pageSize?: number;
                 /** @description Order status (single value or comma-separated list) */
@@ -12862,21 +14346,15 @@ export interface operations {
                 /** @description Sort direction for createdAt */
                 orderBy?: "ASC" | "DESC";
                 /**
-                 * @description Pagination cursor with three distinct states:
-                 *       - Omitted: legacy page-number pagination via `page`, limited to recent
-                 *         history once the archive window is enabled.
-                 *       - Empty string (""): start a cursor walk with no prior position, from
-                 *         the newest row (or the oldest, when `orderBy` is ASC).
+                 * @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
                  *         `next_page_token`; results resume immediately after that position.
                  *
-                 *      In either cursor-walk state (empty or non-empty), `page` is ignored (it
-                 *      comes back as 0), but `total` and `total_pages` ARE populated — bounded by
-                 *      the server count ceiling, see `total_capped`. Results cover full order
-                 *      history — hot and archived rows merged — unlike page-number mode, which
-                 *      only ever sees recent history. Clients that need complete order history
-                 *      must use the cursor form (start with an empty string, then follow
-                 *      next_page_token) rather than `page`. Filters and orderBy must match the
+                 *      `total` and `total_pages` are populated — bounded by the server count
+                 *      ceiling, see `total_capped`. Every walk covers full order history — hot
+                 *      and archived rows merged. Filters and orderBy must match the
                  *      request that produced the token.
                  */
                 pageToken?: string;
@@ -13313,24 +14791,17 @@ export interface operations {
                 /** @description Trading pair identifier (UUID) */
                 tradingPairId?: string;
                 state?: string;
-                /**
-                 * @deprecated
-                 * @description Deprecated: page number for legacy offset pagination (1-indexed). Use pageToken cursor pagination instead.
-                 */
-                page?: number;
                 /** @description Items per page (max 100 in page-number mode; up to 1000 when pageToken is present) */
                 pageSize?: number;
                 /**
-                 * @description Pagination cursor with three distinct states:
-                 *       - Omitted: legacy page-number pagination via `page`.
-                 *       - Empty string (""): start a cursor walk with no prior position, from
-                 *         the newest conditional order.
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest conditional order.
                  *       - Non-empty: an opaque cursor from a previous response's
                  *         `next_page_token`; results resume immediately after that position.
                  *
-                 *      In either cursor-walk state (empty or non-empty), `page` is ignored and
-                 *      `total` is not populated — both come back 0, because cursor mode runs no
-                 *      COUNT (AIP-158). Cursor pages are keyset seeks on `(createdAt, id)`, so a
+                 *      `total` is the matching row count, bounded at a server ceiling of 10,000
+                 *      and saturating there. Pages are keyset seeks on `(createdAt, id)`, so a
                  *      page size up to 1000 is allowed. Filters must match the request that
                  *      produced the token; a token replayed against different filters is
                  *      rejected.
@@ -13424,27 +14895,20 @@ export interface operations {
     list_twap_orders: {
         parameters: {
             query?: {
-                /**
-                 * @deprecated
-                 * @description Deprecated: page number for legacy offset pagination (1-indexed). Use pageToken cursor pagination instead.
-                 */
-                page?: number;
                 /** @description Items per page (max 100 in page-number mode; up to 1000 when pageToken is present) */
                 pageSize?: number;
                 state?: string;
                 /** @description Trading pair identifier (UUID) */
                 tradingPairId?: string;
                 /**
-                 * @description Pagination cursor with three distinct states:
-                 *       - Omitted: legacy page-number pagination via `page`.
-                 *       - Empty string (""): start a cursor walk with no prior position, from
-                 *         the newest TWAP parent.
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position, from the newest TWAP parent.
                  *       - Non-empty: an opaque cursor from a previous response's
                  *         `next_page_token`; results resume immediately after that position.
                  *
-                 *      In either cursor-walk state (empty or non-empty), `page` is ignored and
-                 *      `total` is not populated — both come back 0, because cursor mode runs no
-                 *      COUNT (AIP-158). Cursor pages are keyset seeks on `(createdAt, id)`, so a
+                 *      `total` is the matching row count, bounded at a server ceiling of 10,000
+                 *      and saturating there. Pages are keyset seeks on `(createdAt, id)`, so a
                  *      page size up to 1000 is allowed. Filters must match the request that
                  *      produced the token; a token replayed against different filters is
                  *      rejected.