@0xinsider/sdk 0.37.0 → 0.39.0

package/dist/schema.d.ts

@@ -1001,6 +1001,7 @@ export type EventReplayMeta = {
             condition_id?: string;
             min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
             min_size?: number;
+            min_grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F";
         };
         /** The expansions applied to every event on this page; empty when none. */
         expand: "trade"[];
@@ -1335,6 +1336,10 @@ export type GameFreshness = {
     scores_observed_at?: string;
     /** The provider's own frame clock. Omitted when the frame carries none. */
     scores_source_at?: string;
+    /** Seconds since this game's last Sports WebSocket frame. The esports feed resends an unchanged series about every 20 seconds, so this dates the feed's last frame, not the last score change. Omitted when no Sports WebSocket frame dates the score, which is not age zero: a score read from the provider's event listing is re-read on a cadence whether or not the game moved. */
+    scores_age_seconds?: number;
+    /** Whether this game's score and clock are current, judged on how often this league's feed sends a frame, and independent of source_freshness, which dates the board: a board can be seconds old while one game's frame is frozen. not_applicable outside play (scheduled, final, postponed, cancelled), at halftime and in a break between periods (a period of HT or End ...). stale when the last frame is older than the bound measured for its state: 180 seconds for a running soccer half before stoppage time (the provider sends a frame each match minute); 120 seconds for an in-progress cs2 or lol series (the feed resends each running series about every 20 seconds, so fresh means the provider resent it, not that the map score moved); 600 seconds for a running period of men's and women's college basketball (league cbb, cwbb) and NHL hockey (nhl), whose feeds send no frame while the clock is stopped for a timeout or review. fresh within the bound. unknown otherwise: no dated frame, soccer stoppage time, a period clock at 00:00, End OT in women's college basketball (the end of the third quarter, after which the provider sends no frame until the final), tennis (frames land on points and stop for changeovers and breaks), and every league with no measured bound, including the NBA and NFL. */
+    scores_freshness: "fresh" | "stale" | "unknown" | "not_applicable";
 };
 /** One market of a game holders batch: GET /api/v1/market/{condition_id}/holders unfiltered and cut to the batch limit. */
 export type GameHoldersItem = {
@@ -1347,10 +1352,12 @@ export type GameHoldersItem = {
     market: MarketHoldersMarket;
     scan: MarketHoldersScan;
     totals: MarketHoldersTotals;
-    /** When this roster was computed. A cached roster is at most 60 seconds old. */
+    /** When this roster was computed. A fresh cached roster is at most 60 seconds old; a stale one at most 15 minutes. */
     computed_at: string;
-    /** true when the roster came from the 60-second roster cache. */
+    /** true when the roster came from the cache. */
     cached: boolean;
+    /** true when the market had no fresh roster at the batch deadline and this is the last roster published for it, up to 15 minutes old (read computed_at). The fresh one is still computing, so a read a few seconds later normally gets it; a market refused over the account's cold-read share is served the same way. */
+    stale: boolean;
 };
 /** One Polymarket market linked to this game. */
 export type GameMarket = {
@@ -1810,7 +1817,7 @@ export type LargeTradeInsertedV2Data = {
     trader_id: number;
     /** Address of the wallet that made the trade. */
     wallet: string;
-    /** The wallet's grade when the event was published; `null` when it has none. */
+    /** The wallet's grade when the event was published; `null` when it has none. A backfilled trade publishes hours after it filled, so this can differ from `grade_at_trade`. `min_grade` filters on this field; `min_grade_at_trade` filters on `grade_at_trade`. */
     grade: "S" | "A" | "B" | "C" | "D" | "F" | null;
     /** USD notional of the trade; decimal string. */
     size_usd: string;
@@ -1824,20 +1831,26 @@ export type LargeTradeInsertedV2Data = {
     /** When the trade filled on Polymarket. The envelope's `created_at` is this instant. */
     traded_at: string;
     platform: "polymarket";
+    /** The grade the wallet held when the trade filled, the same fact as `trader.grade_at_trade` on `GET /api/v1/large-trades`; `null` unless `grade_at_trade_status` is `graded`. `min_grade_at_trade` filters on it. */
+    grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F" | null;
+    /** `graded` when `grade_at_trade` holds the grade at the fill; `ungraded` when the wallet had no grade then; `unknown` when it cannot be known, for a trade before 2026-09-19 23:00 UTC or while a grade change is unconfirmed. Only `graded` trades match `min_grade_at_trade`. An event published before these fields shipped (November 2026), or a redelivery of one, carries neither. */
+    grade_at_trade_status?: "graded" | "ungraded" | "unknown";
 };
 /** `large_trades_inserted` data (Pro and Max): new large trades were ingested. It carries a count and no trade; subscribe to `large_trade_inserted_v2` for the trade itself. The deprecated spelling `whale_trades_inserted` delivers the same object until its sunset on 2027-02-01 (#29352). */
 export type LargeTradesInsertedData = {
     /** Large trades the producing batch admitted. */
     count: number;
 };
-/** All present fields narrow large_trade_inserted_v2 delivery. Grade is observed at publication; ungraded trades do not match min_grade. An empty object matches every large trade. */
+/** All present fields narrow large_trade_inserted_v2 delivery. min_grade reads the payload's grade, observed at publication; min_grade_at_trade reads its grade_at_trade, the grade when the trade filled. Send one of the two, not both (400). An empty object matches every large trade. */
 export type LargeTradeSubscriptionFilters = {
     /** Raw provider condition ID or mkt_-prefixed market ID. */
     condition_id?: string;
     /** Polymarket wallet address; matching is case-insensitive. */
     wallet?: string;
-    /** S is best; ungraded trades do not match. */
+    /** S is best; ungraded trades do not match. Reads the wallet's grade when the trade was published, which for a backfilled trade can be hours after the fill. */
     min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+    /** S is best. Reads grade_at_trade, the grade the trader held when the trade filled; only a trade whose grade_at_trade_status is graded matches. The same basis as min_grade_at_trade on GET /api/v1/large-trades and GET /api/v1/stream. */
+    min_grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F";
     /** Positive USD notional as an exact decimal string. */
     min_size_usd?: string;
 };
@@ -1884,17 +1897,28 @@ export type LeaderboardEntry = {
     /** When the wallet last traded: its most recent recorded trade, as of the leaderboard row's last refresh, which re-reads it hourly, so a new trade can take about an hour to show. It agrees with the activity filter: every wallet listed under activity=inactive last traded more than 30 days ago. Since 2026-11-02 (#32322); before, it carried the time 0xinsider last synced the wallet, usually within the past week whether or not the wallet traded. Omitted when the wallet has no recorded trade. */
     last_active?: string;
 };
+/** Every league with a skill leaderboard, by sport: the league values GET /api/v1/leaderboard/sports/{sport} accepts. */
 export type LeaderboardLeagues = {
+    /** Grouped by sport, then most ranked wallets first. */
     leagues: {
+        /** The canonical sport, for example Soccer or Esports. */
         category: string;
+        /** The league's display name. */
         name: string;
+        /** Wallets the league board's edge sort ranks with no hold; at least min_ranked. */
         ranked_traders: number;
+        /** The league slug, the board route's league parameter. */
         slug: string;
+        /** The sport slug, the board route's {sport}. */
         sport: string;
+        /** Wallets with at least min_resolved settled markets in the league and a trade in the last 180 days: the field the league board ranks. */
         total_traders: number;
     }[];
+    /** Wallets a league board's edge sort must rank, with no hold, for the league to be listed. */
     min_ranked: number;
+    /** Settled markets of $20 or more a wallet needs in a league to be on its board. */
     min_resolved: number;
+    /** When the league ranking last ran. It runs about once a day. */
     refreshed_at: string;
 };
 /** Edge over the price paid (#32270): how often the side a wallet bought won, minus the average price it paid, over its settled sports and esports markets of $20 or more at a known entry price. Probabilities throughout: edge 0.12 is 12 percentage points. A wallet buying at 99 cents that wins every market has an edge of about 0.01. A market bought on both sides counts by its shares: the winning side's share of the shares bought is its hit, the cost over those shares its price. */
@@ -1912,6 +1936,21 @@ export type LeaderboardPriceEdge = {
     /** Why the leaderboard does not rank a ranked edge. record_incomplete: the wallet's stored sports and esports record shows more profit than Polymarket reports for it, so some losing markets are likely missing. Omitted when nothing holds the edge, and always omitted unless status is ranked. */
     hold?: "record_incomplete";
 };
+/** The whole board's totals, the counts the 0xinsider leaderboard page shows (#32737), read with the ranking snapshot the page is served at. Sent on every page of a request with no category and no strategy, whatever its sort, dir and activity, which order or split the same wallets. Omitted on a category or strategy page, which lists a subset these totals do not describe, and while the ranking has no totals for the served generation. */
+export type LeaderboardSummary = {
+    /** Ranked wallets on the board: the wallets the unfiltered list pages through. */
+    ranked_total: number;
+    /** Ranked wallets by grade. Every ranked wallet is graded S, A or B, so the three sum to ranked_total. */
+    by_grade: {
+        S: number;
+        A: number;
+        B: number;
+    };
+    /** Ranked wallets whose last trade was 30 days or less before as_of: the wallets activity=active lists. ranked_total minus active_30d is the activity=inactive count. */
+    active_30d: number;
+    /** When the totals were counted, UTC. They are recounted about once a minute while the ranking is current. */
+    as_of: string;
+};
 /** One side's score line inside a `live_sports_updated` pulse. */
 export type LiveSportsScoreEntry = {
     /** Team name, ordered for the league (away first where the league reads that way). */
@@ -2647,6 +2686,13 @@ export type PickOfTheDayArchive = {
     /** One entry per product day that has a published pick included in the archive, newest first, in the same order as picks. Each carries that day's net units, accumulated in the same backend pass and behind the same visibility gate as hit_rate.unit_score, so both cover the same population of picks. Re-adding the day totals reproduces hit_rate.unit_score to display precision rather than bit-for-bit, since that re-associates the floating-point sum. */
     days: PickOfTheDayArchiveDay[];
     hit_rate: PickOfTheDayHitRate;
+    page?: {
+        has_more: boolean;
+        limit: number;
+        next_cursor: string | null;
+        returned: number;
+        total: number;
+    };
 };
 export type PickOfTheDayArchiveDay = {
     /** The product day (YYYY-MM-DD). */
@@ -2742,6 +2788,67 @@ export type PickOfTheDayArchiveEntry = {
      */
     supersedes_pick_id: string | null;
 };
+/** The archive with `view=summary`: `hit_rate` without its daily `series`, one short row per pick, and `page`. Page with `limit` and `cursor`; `view=full` returns every field of a row. */
+export type PickOfTheDayArchiveSummary = {
+    hit_rate: {
+        clv_applicable: number;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_beats_close: number;
+        clv_coverage_display?: string;
+        clv_coverage_explanation?: string;
+        clv_coverage_pct?: number;
+        clv_eligible: number;
+        clv_measured: number;
+        clv_not_applicable: number;
+        clv_pending: number;
+        clv_state: string;
+        clv_ties: number;
+        clv_total: number;
+        clv_unavailable: number;
+        decided: number;
+        losses: number;
+        net_profit_display: string;
+        net_profit_usd: number;
+        pct: number;
+        pending: number;
+        roi_display: string;
+        roi_pct: number;
+        stake_usd: number;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display: string;
+        wins: number;
+    };
+    page: {
+        has_more: boolean;
+        limit: number;
+        next_cursor: string | null;
+        returned: number;
+        total: number;
+    };
+    picks: {
+        backed_price?: number;
+        backed_side_locked?: boolean;
+        clv_pct?: number;
+        display_category?: string;
+        is_free_selection: boolean;
+        matchup?: string;
+        outcome: string;
+        pick_date: string;
+        pick_id: string;
+        pick_outcome_label?: string;
+        publication_order: number;
+        required_tier?: string;
+        top_grade?: string;
+        unit_score?: number;
+    }[];
+    view: string;
+};
 /** Select using the entry commitment_version, never implicit payload shape. All historic v1 hashes remain unchanged. */
 export type PickOfTheDayCommitmentPayload = PickOfTheDayCommitmentPayloadV1 | PickOfTheDayCommitmentPayloadV2;
 /** The frozen identity of the pick, exactly as the hash was taken over it. Served byte for byte as it was hashed -- keys sorted by UTF-8 byte value, no insignificant whitespace -- so a verifier concatenates and hashes with nothing to reconstruct. Property order below is the wire order. The outcome is deliberately NOT part of it: surviving a corrected outcome unchanged is the case the commitment exists for. Worked example: {"backed_price":"0.545000","condition_id":"0xabc","kickoff":"2026-09-20T23:05:00Z","pick_date":"2026-09-20","pick_outcome_index":1,"pick_outcome_label":"Lakers","pick_rank":1,"platform":"polymarket"} with the nonce 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f hashes to 44d18fa5e2aa3a2bf3c971dcc9317c8ccbdfd5480a4773b6d8ffd5fbeeea84dc. */
@@ -2919,6 +3026,8 @@ export type PickOfTheDayLedgerOpenedEntry = {
     supersedes_pick_id: string | null;
     /** Explicit proof provenance: 1 retains historic eight-field canonical JSON; 2 binds stable pick_id and version without pick_rank. */
     commitment_version: 1 | 2;
+    /** How the pick was chosen: auto by the selection algorithm, manual by an operator (102 published picks from 2026-06-23 to 2026-10-15; none since). Outside the hashed payload, so it moves no commitment. */
+    selected_by: "auto" | "manual";
 };
 /** An unresolved published pick. Carries only date, rank, hash, algorithm, seal instant and permalink. Kickoff and game identity are withheld; seal time remains public commitment provenance. */
 export type PickOfTheDayLedgerSealedEntry = {
@@ -2951,6 +3060,8 @@ export type PickOfTheDayLedgerSealedEntry = {
     supersedes_pick_id: string | null;
     /** Explicit proof provenance: 1 retains historic eight-field canonical JSON; 2 binds stable pick_id and version without pick_rank. */
     commitment_version: 1 | 2;
+    /** How the pick was chosen: auto by the selection algorithm, manual by an operator (102 published picks from 2026-06-23 to 2026-10-15; none since). Outside the hashed payload, so it moves no commitment. */
+    selected_by: "auto" | "manual";
 };
 /** A pick without a commitment, retained so the record cannot omit unprovable entries. Unresolved entries omit game identity; once resolved, matchup, category and payload become public. Existing opened canonical payload bytes and hashes are unchanged. */
 export type PickOfTheDayLedgerUncommittedEntry = {
@@ -2989,6 +3100,8 @@ export type PickOfTheDayLedgerUncommittedEntry = {
      * @deprecated
      */
     supersedes_pick_id: string | null;
+    /** How the pick was chosen: auto by the selection algorithm, manual by an operator (102 published picks from 2026-06-23 to 2026-10-15; none since). Outside the hashed payload, so it moves no commitment. */
+    selected_by: "auto" | "manual";
 };
 /** A successful current-day entitlement response when only unauthorized ranks have published. It carries an empty pick set, identity-free locked ranks and an upgrade message. Selection IDs, game identity, prices and unauthorized clocks are absent. Any scheduled or proof-pending rows are entitled rows. */
 export type PickOfTheDayNoEntitledPicks = {
@@ -3003,20 +3116,451 @@ export type PickOfTheDayNoEntitledPicks = {
     /** Unauthorized unresolved published or scheduled ranks. Contains no game, provider identity, price, or identifying clock. Pro may upgrade to Max to open these ranks. */
     locked_picks: {
         pick_rank: number;
-        required_tier: "max";
+        required_tier: "max";
+    }[];
+    /** Actionable status, including Upgrade to Max when only locked ranks are published. */
+    message: string;
+    /** Rank-ordered entitled selections that have not released. Every row retains release_at and kickoff; unauthorized scheduled ranks appear only in identity-free locked_picks. */
+    scheduled_picks?: ScheduledPickSlot[];
+    /**
+     * Deprecated (#24157): always null. No replacement lineage was ever recorded in this field; the key stays so existing V1 clients keep parsing. Identify a pick by pick_id.
+     * @deprecated
+     */
+    supersedes_pick_id: string | null;
+};
+export type PickOfTheDayStats = {
+    categories: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
+    }[];
+    days: ({
+        date: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        sweep?: "win" | "loss";
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        wins: number;
+    })[];
+    hit_rate: PickOfTheDayHitRate;
+    market_expectations: {
+        as_of_date: string;
+        price_basis: string;
+        timezone: string;
+        windows: ({
+            clv_avg_display: string | null;
+            clv_avg_pct: number | null;
+            clv_avg_pp: number | null;
+            clv_avg_pp_display: string | null;
+            clv_measured: number;
+            clv_missing: number;
+            expected_wins: number | null;
+            expected_wins_display: string | null;
+            from_date: string | null;
+            key: string;
+            label: string;
+            numeric_unavailable: boolean;
+            priced_decided: number;
+            through_date: string;
+            units: number | null;
+            units_display: string | null;
+            units_z: number | null;
+            units_z_display: string | null;
+            unpriced_decided: number;
+            wins: number;
+            wins_z: number | null;
+            wins_z_display: string | null;
+        })[];
+    };
+    market_types: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
+    }[];
+    months: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
+    }[];
+    outcome_stats: {
+        concentration: {
+            positive_wins: number;
+            remaining_valued_decided: number;
+            removed_wins: number;
+            roi_without_top_wins_display: string | null;
+            roi_without_top_wins_pct: number | null;
+            target_wins: number;
+            top_wins_share_display: string | null;
+            top_wins_share_pct: number | null;
+            valued_decided: number;
+        };
+        drawdown: {
+            completed_days: number;
+            current_days_below_peak: number | null;
+            current_drawdown_display: string | null;
+            current_drawdown_units: number | null;
+            days_below_peak: number | null;
+            excluded_days: number;
+            from_date: string | null;
+            longest_days_below_peak: number | null;
+            longest_recovery_days: number | null;
+            max_drawdown_display: string | null;
+            max_drawdown_units: number | null;
+            peak_date: string | null;
+            peak_net_profit_usd: number | null;
+            through_date: string | null;
+        };
+        profit_factor: {
+            display: string | null;
+            gross_loss_usd: number | null;
+            gross_profit_usd: number | null;
+            state: "empty" | "measured" | "no_losses" | "numeric_unavailable";
+            value: number | null;
+            valued_decided: number;
+        };
+        rolling: ({
+            from_date: string | null;
+            losses: number;
+            roi_display: string | null;
+            roi_pct: number | null;
+            through_date: string | null;
+            units: number | null;
+            units_display: string | null;
+            valued_decided: number;
+            win_rate_display: string | null;
+            win_rate_pct: number | null;
+            window_size: number;
+            wins: number;
+        })[];
+    };
+    price_bands: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
+    }[];
+    records: {
+        best_day?: {
+            date: string;
+            date_display: string;
+            losses: number;
+            net_profit_display: string;
+            net_profit_usd: number;
+            picks: number;
+            wins: number;
+        };
+        biggest_win?: {
+            category: string;
+            date: string;
+            date_display: string;
+            matchup: string;
+            net_profit_display: string;
+            net_profit_usd: number;
+        };
+        longest_losing_day_streak?: {
+            days: number;
+            end_date: string;
+            net_profit_display: string;
+            net_profit_usd: number;
+            range_display: string;
+            start_date: string;
+        };
+        longest_winning_day_streak?: {
+            days: number;
+            end_date: string;
+            net_profit_display: string;
+            net_profit_usd: number;
+            range_display: string;
+            start_date: string;
+        };
+        sweeps: {
+            clean_sweeps: number;
+            latest_clean_sweep?: {
+                date: string;
+                date_display: string;
+                losses: number;
+                wins: number;
+            };
+            latest_wipeout?: {
+                date: string;
+                date_display: string;
+                losses: number;
+                wins: number;
+            };
+            min_decided: number;
+            wipeouts: number;
+        };
+        winning_days?: {
+            flat: number;
+            losing: number;
+            settled: number;
+            winning: number;
+            winning_pct: number;
+            winning_pct_display: string;
+        };
+        worst_day?: {
+            date: string;
+            date_display: string;
+            losses: number;
+            net_profit_display: string;
+            net_profit_usd: number;
+            picks: number;
+            wins: number;
+        };
+    };
+    sports: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
+    }[];
+    streaks: {
+        current?: number;
+        current_day?: number;
+        current_day_display?: string;
+        current_display?: string;
+        longest_loss: number;
+        longest_win: number;
+    };
+    tiers: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
+    }[];
+    total_sides: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
+    }[];
+    voids: {
+        backed_price?: number;
+        backed_side?: string;
+        category?: string;
+        matchup?: string;
+        pick_date: string;
+        pick_id: string;
+        pick_rank: number;
+    }[];
+    selections: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
     }[];
-    /** Actionable status, including Upgrade to Max when only locked ranks are published. */
-    message: string;
-    /** Rank-ordered entitled selections that have not released. Every row retains release_at and kickoff; unauthorized scheduled ranks appear only in identity-free locked_picks. */
-    scheduled_picks?: ScheduledPickSlot[];
-    /**
-     * Deprecated (#24157): always null. No replacement lineage was ever recorded in this field; the key stays so existing V1 clients keep parsing. Identify a pick by pick_id.
-     * @deprecated
-     */
-    supersedes_pick_id: string | null;
 };
-export type PickOfTheDayStats = {
-    categories: {
+/** The stats with `view=summary` or `sections`: only the named sections, listed in `sections`. `view=summary` names every section except `series`, `days`, `categories`, `months` and `voids`. */
+export type PickOfTheDayStatsSections = {
+    categories?: {
         canonical_category?: string;
         clv_avg_display?: string;
         clv_avg_pct?: number;
@@ -3047,7 +3591,7 @@ export type PickOfTheDayStats = {
         win_rate_pct?: number;
         wins: number;
     }[];
-    days: ({
+    days?: ({
         date: string;
         losses: number;
         net_profit_display?: string;
@@ -3060,8 +3604,41 @@ export type PickOfTheDayStats = {
         void: number;
         wins: number;
     })[];
-    hit_rate: PickOfTheDayHitRate;
-    market_expectations: {
+    hit_rate?: {
+        clv_applicable: number;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_beats_close: number;
+        clv_coverage_display?: string;
+        clv_coverage_explanation?: string;
+        clv_coverage_pct?: number;
+        clv_eligible: number;
+        clv_measured: number;
+        clv_not_applicable: number;
+        clv_pending: number;
+        clv_state: string;
+        clv_ties: number;
+        clv_total: number;
+        clv_unavailable: number;
+        decided: number;
+        losses: number;
+        net_profit_display: string;
+        net_profit_usd: number;
+        pct: number;
+        pending: number;
+        roi_display: string;
+        roi_pct: number;
+        stake_usd: number;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display: string;
+        wins: number;
+    };
+    market_expectations?: {
         as_of_date: string;
         price_basis: string;
         timezone: string;
@@ -3090,7 +3667,7 @@ export type PickOfTheDayStats = {
             wins_z_display: string | null;
         })[];
     };
-    market_types: {
+    market_types?: {
         canonical_category?: string;
         clv_avg_display?: string;
         clv_avg_pct?: number;
@@ -3121,7 +3698,7 @@ export type PickOfTheDayStats = {
         win_rate_pct?: number;
         wins: number;
     }[];
-    months: {
+    months?: {
         canonical_category?: string;
         clv_avg_display?: string;
         clv_avg_pct?: number;
@@ -3152,7 +3729,7 @@ export type PickOfTheDayStats = {
         win_rate_pct?: number;
         wins: number;
     }[];
-    outcome_stats: {
+    outcome_stats?: {
         concentration: {
             positive_wins: number;
             remaining_valued_decided: number;
@@ -3203,7 +3780,7 @@ export type PickOfTheDayStats = {
             wins: number;
         })[];
     };
-    price_bands: {
+    price_bands?: {
         canonical_category?: string;
         clv_avg_display?: string;
         clv_avg_pct?: number;
@@ -3234,7 +3811,7 @@ export type PickOfTheDayStats = {
         win_rate_pct?: number;
         wins: number;
     }[];
-    records: {
+    records?: {
         best_day?: {
             date: string;
             date_display: string;
@@ -3303,7 +3880,13 @@ export type PickOfTheDayStats = {
             wins: number;
         };
     };
-    sports: {
+    sections: string[];
+    series?: {
+        date: string;
+        hit_rate_pct: number;
+        net_profit_usd: number;
+    }[];
+    sports?: {
         canonical_category?: string;
         clv_avg_display?: string;
         clv_avg_pct?: number;
@@ -3334,7 +3917,7 @@ export type PickOfTheDayStats = {
         win_rate_pct?: number;
         wins: number;
     }[];
-    streaks: {
+    streaks?: {
         current?: number;
         current_day?: number;
         current_day_display?: string;
@@ -3342,7 +3925,7 @@ export type PickOfTheDayStats = {
         longest_loss: number;
         longest_win: number;
     };
-    tiers: {
+    tiers?: {
         canonical_category?: string;
         clv_avg_display?: string;
         clv_avg_pct?: number;
@@ -3373,7 +3956,7 @@ export type PickOfTheDayStats = {
         win_rate_pct?: number;
         wins: number;
     }[];
-    total_sides: {
+    total_sides?: {
         canonical_category?: string;
         clv_avg_display?: string;
         clv_avg_pct?: number;
@@ -3404,7 +3987,8 @@ export type PickOfTheDayStats = {
         win_rate_pct?: number;
         wins: number;
     }[];
-    voids: {
+    view: string;
+    voids?: {
         backed_price?: number;
         backed_side?: string;
         category?: string;
@@ -3413,6 +3997,37 @@ export type PickOfTheDayStats = {
         pick_id: string;
         pick_rank: number;
     }[];
+    selections?: {
+        canonical_category?: string;
+        clv_avg_display?: string;
+        clv_avg_pct?: number;
+        clv_avg_pp?: number;
+        clv_avg_pp_display?: string;
+        clv_measured: number;
+        edge_display?: string;
+        edge_pp?: number;
+        key: string;
+        label: string;
+        losses: number;
+        net_profit_display?: string;
+        net_profit_usd?: number;
+        pending: number;
+        picks: number;
+        priced_decided: number;
+        priced_in_display?: string;
+        priced_in_pct?: number;
+        roi_display?: string;
+        roi_pct?: number;
+        settled: number;
+        small_sample: boolean;
+        staked_usd: number;
+        unit_score?: number;
+        unit_score_display?: string;
+        void: number;
+        win_rate_display?: string;
+        win_rate_pct?: number;
+        wins: number;
+    }[];
 };
 /** A settled uncommitted pick's market, side and price. The same eight fields as PickOfTheDayCommitmentPayload, in the same key order, so a settled pick's side and price sit under payload whatever the entry's state. It is NOT a commitment: no hash was taken over it before the game, and it proves nothing about when the pick was made. */
 export type PickOfTheDayUncommittedPayload = {
@@ -4000,48 +4615,88 @@ export type SnapshotState = {
     /** When this body's source read started, the clock finality is judged on. null for a body stored before that clock was recorded. */
     source_read_started_at: string | null;
 };
+/** One sport's skill leaderboard, or one league's. Every figure on a row is the wallet's record in this sport or league, except grade, the wallet's all-time grade, and volume (see volume_scope). */
 export type SportLeaderboard = {
+    /** The latest time any wallet's record on this board was recomputed. The sport ranking reruns hourly, a league ranking about once a day. null when the board has no rows. */
     as_of: string | null;
+    /** The canonical sport the slug resolved to, for example Soccer or Basketball. null when no wallet has a record under it; rows is then empty. */
     category: string | null;
+    /** The mean edge over every wallet in the field whose price_edge.status is ranked, held ones included: the value each row's edge_skill is pulled toward. null when no wallet's edge is ranked. */
     edge_average: number | null;
+    /** The league this board ranks; null on a sport board. */
     league: {
+        /** The league's display name. */
         name: string;
+        /** Wallets the league board's edge sort ranks with no hold. */
         ranked_traders: number;
+        /** The league's slug under its sport, for example premier-league or cs2. */
         slug: string;
     } | null;
+    /** The requested limit after clamping to 1..100 (default 20). rows holds fewer when the board has fewer wallets. */
     limit: number;
+    /** Settled markets of $20 or more a wallet needs in the sport or league to be on the board. */
     min_resolved: number;
+    /** The head of the board, in sort order. Every figure is the wallet's record in this sport or league, except grade (all-time) and volume (see volume_scope). */
     rows: ({
+        /** Lowercase proxy wallet. */
         address: string;
+        /** What the wallet paid, USD, for the settled markets pnl counts. null when any of them has no stored cost, never a partial sum. */
         cost: number | null;
+        /** Why sort=edge sets aside an edge whose status is ranked. category_loss: the wallet's realized P&L in this sport or league is zero or below. record_incomplete: the wallet's stored sports and esports P&L runs more than 5% of its cost ahead of Polymarket's own figure, so settled losing markets are likely missing from its record. A held row keeps its price_edge and edge_skill and sorts after the ranked rows on sort=edge. null when nothing holds the edge, and always null unless price_edge.status is ranked. */
         edge_hold: "category_loss" | "record_incomplete" | null;
+        /** price_edge.edge pulled toward edge_average by the share of the record that is noise: a short record moves most of the way to the average, a long one keeps nearly all of its own edge. The value sort=edge orders by when edge_hold is null. null unless price_edge.status is ranked. */
         edge_skill: number | null;
+        /** The wallet's all-time grade, S to F, the one every route serves. It is led by realized profit across all of the wallet's sports and esports markets, not this sport's or league's, so a wallet can lead a board on in-sport P&L and still grade F. Every letter is listed: the board ranks the in-sport record and does not filter on the grade. null when the wallet has no grade. */
         grade: "S" | "A" | "B" | "C" | "D" | "F" | null;
+        /** trd_0x..., the id the trader routes accept. */
         id: string;
+        /** The wallet's last trade on a settled market of $20 or more in this sport or league. */
         last_category_trade_at: string | null;
+        /** Markets n_resolved counts that settled at a realized loss. A market that broke even counts in neither wins nor losses. */
         losses: number;
+        /** The wallet's settled markets of $20 or more in this sport or league; at least min_resolved. */
         n_resolved: number;
+        /** Provider platform. Always polymarket. */
         platform: "polymarket";
+        /** Realized P&L, USD, across the markets n_resolved counts: this sport or league only, not the wallet's whole record. The value sort=pnl orders by. */
         pnl: number | null;
+        /** Edge over the price paid in this sport or league: how often the side the wallet bought won, minus the average price it paid. Probabilities throughout: edge 0.03 is 3 percentage points. A market bought on both sides counts by its shares. null when the wallet has no priced settled market here. */
         price_edge: {
+            /** Mean entry price paid, 0-1. */
             avg_price: number;
+            /** hit_rate minus avg_price, full precision, before any shrink. edge_skill is the shrunk value. */
             edge: number;
+            /** The low end of edge's 95% range: edge minus 1.96 times the square root of avg_price * (1 - avg_price) / markets. Not a sort key: sort=edge orders by edge_skill. */
             edge_lower: number;
+            /** Share of those markets whose bought side won, 0-1. A market bought on both sides adds the winning side's share of the shares bought. */
             hit_rate: number;
+            /** Settled markets of $20 or more in this sport or league at a known entry price that the edge is measured over. */
             markets: number;
+            /** Whether the edge ranks. ranked: at least 30 such markets, and the share of the decided ones that made money at settlement within 10 points of the win rate here. too_few_markets: fewer than 30. sample_mismatch: that share is more than 10 points away, so these markets do not describe the wallet's record. Only a ranked edge with a null edge_hold orders on sort=edge. */
             status: "ranked" | "too_few_markets" | "sample_mismatch";
         } | null;
+        /** 1-based position on this board under sort. A page of limit rows is the head of the board. */
         rank: number;
+        /** pnl / cost, a fraction: 0.12 is 12%. null when cost is null. */
         roi: number | null;
+        /** The wallet's Polymarket username; null when it has none. */
         username: string | null;
+        /** USD, measured as volume_scope says. On a sport board: the wallet's volume across all its sports and esports markets, the profile's Volume traded, not this sport's alone. null on every league board row: no per-league volume is stored. */
         volume: number | null;
+        /** wins / (wins + losses) in this sport or league, 0-1: 0.6 is 60%. null when no market was decided. */
         win_rate: number | null;
+        /** The lower bound of the 95% Wilson interval on win_rate, 0-1: the value sort=win_rate orders by, so a short perfect record does not outrank a long strong one. null with win_rate. */
         win_rate_wilson_lb: number | null;
+        /** Markets n_resolved counts that settled at a realized profit. */
         wins: number;
     })[];
+    /** The order rows are in. edge: by edge_skill, with every wallet whose edge is not ranked, or is held, after the ranked ones. pnl: by realized P&L in the sport or league. win_rate: by the Wilson lower bound of the win rate. */
     sort: "edge" | "pnl" | "win_rate";
+    /** The board's sport slug, for example soccer, basketball or esports. An alias in the path, such as nba or cs2, reads as its sport's slug. */
     sport: string;
+    /** Wallets with at least min_resolved settled markets in the sport or league and a trade, in any market, in the last 180 days: the field rows is the head of. */
     total_traders: number;
+    /** What each row's volume measures. sports_and_esports: the wallet's volume across all its sports and esports markets, not this sport's or league's alone. */
     volume_scope: "sports_and_esports";
 };
 export type SuspiciousTrade = {
@@ -4326,7 +4981,7 @@ export type TraderContext = {
     /** Human-readable statement of the point-in-time snapshot semantics (data_as_of is the open-position clock -- the latest /positions snapshot, else the last completed sync; the snapshot advances only open positions, so resolved counts and win rate can include settled markets recorded after the last full sync; native realized P&L follows its accounting snapshot -- not a live feed; re-fetch for fresher data). */
     freshness_note: string;
 };
-/** Results by the entry price the wallet paid for the side it held, over its sports and esports markets with a known held entry price. */
+/** Results by the entry price the wallet paid for the side it held, over its settled sports and esports positions with a held entry price. coverage counts the settled positions the buckets leave out, and why. */
 export type TraderEntryPriceAnalysis = {
     /** One bucket per price band that has a market, in bucket_order. */
     buckets: TraderEntryPriceBucket[];
@@ -4334,10 +4989,12 @@ export type TraderEntryPriceAnalysis = {
     best_bucket: string | null;
     /** The bucket with the lowest win rate among buckets of at least 3 markets. null when no bucket has 3. */
     worst_bucket: string | null;
+    /** What the buckets cover (since 2026-11-03, #32671). */
+    coverage: TraderEntryPriceCoverage;
 };
 /** One entry-price band. Each measure is an analytic value: read state before value. */
 export type TraderEntryPriceBucket = {
-    /** The band: $0.01-$0.19, $0.20-$0.39, $0.40-$0.59, $0.60-$0.79 or $0.80-$0.99. The last also holds any price below $0.01. */
+    /** The band: $0.00-$0.19 (any price below $0.20, sub-cent fills included), $0.20-$0.39, $0.40-$0.59, $0.60-$0.79 or $0.80-$0.99. Until 2026-11-03 the first band was $0.01-$0.19 and sub-cent fills had no bucket (#32671). */
     bucket: string;
     /** Display position, 0 first, from the lowest price up. */
     bucket_order: number;
@@ -4352,6 +5009,28 @@ export type TraderEntryPriceBucket = {
     /** Mean realized P&L of a market in the band, USD. */
     avg_pnl: AnalyticNumber;
 };
+/** The settled sports and esports positions the entry-price section reads. The buckets' markets plus every unbucketed row's are settled_markets, and their realized P&L sums to settled_pnl. settled_pnl adds up the wallet's per-market realized P&L, so it differs from pnl.in_scope.realized_pnl, which is Polymarket's published sports and esports P&L with a share of the wallet's rebates. */
+export type TraderEntryPriceCoverage = {
+    /** Settled sports and esports positions: bucketed_markets plus every unbucketed row's markets. */
+    settled_markets: number;
+    /** Realized P&L of those positions, USD. */
+    settled_pnl: number;
+    /** Positions in a bucket: the sum of buckets[].markets. */
+    bucketed_markets: number;
+    /** Realized P&L of the bucketed positions, USD: the sum of buckets[].total_pnl. */
+    bucketed_pnl: number;
+    /** The settled positions the buckets leave out: one row for each reason that has a position, ordered by reason. Empty when the buckets hold every settled position. */
+    unbucketed: TraderEntryPriceUnbucketed[];
+};
+/** Settled positions with no entry-price bucket, for one reason. */
+export type TraderEntryPriceUnbucketed = {
+    /** two_sided: both outcomes bought at a price, a hedged book with no single side. held_side_unpriced: one outcome has a recorded price, but the wallet's remaining shares are on the other. no_entry_price: no outcome has a recorded entry price. freshness_unknown: a bucket whose rows carry no freshness clock yet. */
+    reason: "two_sided" | "held_side_unpriced" | "no_entry_price" | "freshness_unknown";
+    /** Positions left out for this reason. */
+    markets: number;
+    /** Their realized P&L, USD. */
+    total_pnl: number;
+};
 export type TraderEsportsGameRecord = {
     /** The game, by the same name every holder chip carries in category_win_rate_game: LoL, CS2, Dota 2, Valorant, Call of Duty, Honor of Kings, Mobile Legends: Bang Bang, Overwatch, Rainbow Six Siege, Rocket League or StarCraft II. Match a chip to this row by string equality. */
     game: string;
@@ -5397,11 +6076,64 @@ export interface OperationData {
     getMarketTopHolders: MarketTopHolders;
     getMarketWalletsInOut: MarketWalletsInOut;
     getMonthlyReportSnapshot: ReportSnapshot;
-    getPickOfTheDay: PickOfTheDay | PickOfTheDayNoEntitledPicks;
-    getPickOfTheDayArchive: PickOfTheDayArchive;
+    getPickOfTheDay: PickOfTheDay | PickOfTheDayNoEntitledPicks | {
+        disclaimer?: string;
+        locked_picks?: {
+            pick_rank: number;
+            required_tier: string;
+        }[];
+        pick_count: number;
+        pick_date: string;
+        picks: {
+            backed_price?: number;
+            category?: string;
+            clv_pct?: number;
+            clv_status?: string;
+            display_category?: string;
+            event_slug?: string;
+            game_ended?: boolean;
+            game_started?: boolean;
+            holder_count?: number;
+            is_free_selection: boolean;
+            matchup?: string;
+            outcome?: string;
+            pick_id: string;
+            pick_outcome_label?: string;
+            polymarket_url?: string;
+            publication_order: number;
+            release_at?: string;
+            return_usd?: number;
+            stake_usd?: number;
+            token_id?: string;
+            top_grade?: string;
+            unit_score?: number;
+        }[];
+        proof_pending_picks?: ({
+            is_free_selection: boolean;
+            kickoff?: string;
+            pick_id: string;
+            pick_rank: number;
+            publication_order: number;
+            release_at: string;
+            retry_at: string;
+            supersedes_pick_id: string | null;
+        })[];
+        scheduled_picks?: ({
+            is_free_selection: boolean;
+            kickoff: string;
+            pick_id: string;
+            pick_rank: number;
+            publication_order: number;
+            release_at: string;
+            supersedes_pick_id: string | null;
+        })[];
+        state: string;
+        view: string;
+    };
+    getPickOfTheDayArchive: PickOfTheDayArchive | PickOfTheDayArchiveSummary;
     getPickOfTheDayLedger: PickOfTheDayLedger;
     getPickOfTheDayLedgerEntry: PickOfTheDayLedgerEntry;
-    getPickOfTheDayStats: PickOfTheDayStats;
+    getPickOfTheDayStats: PickOfTheDayStats | PickOfTheDayStatsSections;
     getPlatforms: Platforms;
     getPositionTimeline: PositionTimelineEvent[];
     getPositionTimelineById: PositionTimelineEvent[];
@@ -5744,7 +6476,7 @@ export interface OperationQuery {
     createWebhookVerificationAttempt: Record<string, never>;
     deleteWebhook: Record<string, never>;
     exploreMarkets: {
-        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Facet values are returned as the canonical bucket. Sports and esports only (#27411): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Facet values are returned as the canonical bucket. Sports and esports only (#27411): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). The Sports facet counts that catch-all category alone. */
         category?: string;
         /** Filter by market status. A market is closed once Polymarket has closed trading or it has resolved, and active otherwise; all returns both. */
         status?: "active" | "closed" | "all";
@@ -5781,7 +6513,7 @@ export interface OperationQuery {
     getEdgeHunter: {
         /** Response mode. board preserves the full quoted board; signals exposes ranked records and category evidence; observations exposes cohort measurements and accountable funnel evidence. Defaults to board. */
         view?: "board" | "signals" | "observations";
-        /** Legacy canonical bucket alias, now accepted in every view. Provider aliases canonicalize: NFL reaches Football and EPL reaches Soccer. Use leagues for a league-specific selection. An unmappable non-sport category returns an empty result and echoes category non_sport. Combines with other selection axes using AND. */
+        /** Legacy canonical bucket alias, now accepted in every view. Provider aliases canonicalize: NFL reaches Football and EPL reaches Soccer. Use leagues for a league-specific selection. The word sports, in any casing, reads as kind=sports, every sport but Esports, as category=sports does on every other route (#32720): the response echoes kind sports beside category sports, and with kind=esports it returns 400 with param category. Any other unmappable non-sport category returns an empty result and echoes category non_sport. Combines with other selection axes using AND. */
         category?: string;
         /** Required for view=observations; wider_holder, in_play or emerging_pile. Rejected for board and signals. wider_holder covers pregame markets that view=signals does not list at its widest selection (horizon_hours=48, min_grade=B, no selector), so until kickoff a market is read in one view or the other. A market view=signals lists leaves wider_holder as primary_slate_candidate, and is a wider_holder candidate again in the first refresh after view=signals stops listing it; signals_as_of names the view=signals snapshot each refresh read. Each refresh evaluates at most 8 markets per sport and cohort, wider_holder by soonest kickoff (most graded holders first among equal kickoffs) and in_play by most graded holders, so a market among a sport's 8 soonest stays evaluated until its game starts. wider_holder also evaluates up to 8 more markets per sport that kick off within 24 hours, most graded holders first, so the most-held markets appear up to a day before kickoff. Each of these keeps its place in later refreshes until its game starts while its holder page still shows a card or could not be read, so a more-held market waits for a free place instead of displacing it. Each row's admitted_by names its place, most_held or soonest_kickoff. The rest count in coverage.capacity_limited_markets. Emerging pile is a wider-holder projection with sharp_pct in [0.75,0.85), complete holder scans and future kickoff, not an independent population or arrival history. */
         cohort?: "wider_holder" | "in_play" | "emerging_pile";
@@ -5811,7 +6543,7 @@ export interface OperationQuery {
         series_slugs?: string[];
     };
     getEventReplaySince: {
-        /** Opaque event replay cursor returned as next_cursor by a prior response. The cursor maps to the global (whale_alerts.inserted_xid, whale_alerts.id) commit-order position, is valid across backend replicas, and is bound to the filter set the walk ran with (trader, condition_id, min_grade, min_size): presenting it under different filters answers 400 bad_request with error.reason cursor_expired, and the walk restarts without a cursor. Cursors issued before 2026-09-22 (id-only) stay accepted and are bound to no filters. Omit to fetch the latest durable public suffix. */
+        /** Opaque event replay cursor returned as next_cursor by a prior response. The cursor maps to the global (whale_alerts.inserted_xid, whale_alerts.id) commit-order position, is valid across backend replicas, and is bound to every filter the walk ran with (trader, condition_id, min_grade, min_grade_at_trade, min_size; expand is not a filter): presenting it under different filters, including a switch between min_grade and min_grade_at_trade, answers 400 bad_request with error.reason cursor_expired, and the walk restarts without a cursor. Cursors issued before 2026-09-22 (id-only) stay accepted and are bound to no filters. Omit to fetch the latest durable public suffix. */
         cursor?: string;
         /** Maximum durable public whale-trade events to return. Out-of-range values are clamped to 1..100. */
         limit?: number;
@@ -5819,8 +6551,10 @@ export interface OperationQuery {
         trader?: string;
         /** Only trades on this market: the raw provider condition_id or its mkt_-prefixed id. Bound to the cursor. */
         condition_id?: string;
-        /** Only trades by wallets at this grade or better (S best), read from the wallet's newest ranking at request time; a wallet with no grade never passes. Bound to the cursor. */
+        /** Only trades by wallets at this grade or better (S best), read from the wallet's newest ranking at request time; a wallet with no grade never passes. For the grade the wallet held when the trade filled, send min_grade_at_trade instead. Bound to the cursor. */
         min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Only trades whose grade_at_trade, the grade the wallet held when the trade filled, is at this grade or better (S best). Only a trade whose grade at the fill is graded passes, so a trade before 2026-09-19T23:00Z, or one made while the wallet's grade was changing, never does. The same basis as min_grade_at_trade on GET /api/v1/large-trades, GET /api/v1/stream and webhook trade_filters. Bound to the cursor: switching between min_grade and min_grade_at_trade is a filter change and answers cursor_expired. Sending it with min_grade, or an invalid grade, returns HTTP 400. */
+        min_grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F";
         /** Only trades of at least this USD amount. Decimal and scientific query spellings normalize exactly to cents, rounding half away from zero; maximum 1e15 USD. Pass the dataset continuation decimal string unchanged to preserve the bound. Bound to the cursor. */
         min_size?: number | string;
         /** Backward-compatible alias for expand. Repeatable: trade. */
@@ -5887,11 +6621,29 @@ export interface OperationQuery {
     getPickOfTheDay: {
         /** A product day (America/New_York) in YYYY-MM-DD format, on or before today. Omit it, or send today, for the current read. A past day with no published pick returns 404 not_found with error.param=date; a date after today, or a value that is not a date, returns 400 bad_request with error.param=date. */
         date?: string;
+        /** full (default) is the whole recorded set: every pick with its holders, lead backer, sports context, thesis and entry_authorization, and the top-level copy of the first pick. summary returns pick_date, pick_count, the disclaimer once, and each entitled pick's identity, side, price, result, return and grade (pick_id, publication_order, is_free_selection, matchup, category, display_category, event_slug, polymarket_url, token_id, pick_outcome_label, outcome, backed_price, stake_usd, return_usd, unit_score, top_grade, holder_count, clv_status, clv_pct, release_at, game_started, game_ended), with the same scheduled_picks, proof_pending_picks and locked_picks. The locked-only state=none body is the same in both views. Any other value returns 400 bad_request with error.param=view. */
+        view?: "full" | "summary";
+        /** One entitled published pick of the day, by its stable decimal-string pick_id. The body carries that pick once, as picks[0], beside state, pick_date and pick_count=1. It leaves out the top-level copy of the first pick that a set read without pick_id repeats, and scheduled_picks, proof_pending_picks and locked_picks. Pair it with date for a past day's pick. A pick_id that is not among the day's entitled published picks returns 404 not_found with error.param=pick_id; one whose holder proof is not readable yet returns 503 read_model_warming with Retry-After; a value that is not a positive canonical decimal returns 400 bad_request with error.param=pick_id. */
+        pick_id?: string;
+    };
+    getPickOfTheDayArchive: {
+        /** full (default) is every row with every field, plus days and hit_rate with its per-pick series. summary returns view, hit_rate without series, one page of short rows (pick_id, pick_date, publication_order, is_free_selection, matchup, display_category, pick_outcome_label, outcome, top_grade, backed_price, unit_score, clv_pct, backed_side_locked, required_tier) and page; it always pages, 50 rows unless limit says otherwise. Any other value returns 400 bad_request with error.param=view. */
+        view?: "full" | "summary";
+        /** Rows per page of picks, 1 to 200, default 50. An integer outside that range is clamped into it, like every list limit, and X-Effective-Query reports the limit applied; a value that is not an integer returns 400 invalid_query. On view=full, sending limit or cursor pages picks and adds page, while days and hit_rate still describe the whole record; with neither, the response is the whole record. */
+        limit?: number;
+        /** The page.next_cursor of the previous page: the rows after it, newest first. A cursor is a position in the record, so a pick published while you page does not shift later pages. A value this route did not return returns 400 bad_request with error.param=cursor. */
+        cursor?: string;
     };
-    getPickOfTheDayArchive: Record<string, never>;
     getPickOfTheDayLedger: Record<string, never>;
     getPickOfTheDayLedgerEntry: Record<string, never>;
-    getPickOfTheDayStats: Record<string, never>;
+    getPickOfTheDayStats: {
+        /** full (default) is every section. summary returns view, sections and every section except the five that grow with the record: series, days, categories, months and voids. In summary and sections bodies hit_rate carries no series; series is its own top-level section. Ignored when sections is sent. Any other value returns 400 bad_request with error.param=view. */
+        view?: "full" | "summary";
+        /** Exactly the sections to return, in the body's order whatever the request order. Repeatable and comma-separated: hit_rate, series, market_expectations, outcome_stats, days, categories, sports, tiers, selections, months, price_bands, market_types, total_sides, streaks, records, voids. The body names them in sections and carries view=sections. An unrecognized name returns 400 bad_request with error.param=sections rather than being ignored. */
+        sections?: ("hit_rate" | "series" | "market_expectations" | "outcome_stats" | "days" | "categories" | "sports" | "tiers" | "selections" | "months" | "price_bands" | "market_types" | "total_sides" | "streaks" | "records" | "voids")[];
+        /** Backward-compatible bracket alias for sections, for clients that emit array keys. Repeatable and comma-separated, with the same names. */
+        "sections[]"?: ("hit_rate" | "series" | "market_expectations" | "outcome_stats" | "days" | "categories" | "sports" | "tiers" | "selections" | "months" | "price_bands" | "market_types" | "total_sides" | "streaks" | "records" | "voids")[];
+    };
     getPlatforms: Record<string, never>;
     getPositionTimeline: {
         /** Market condition_id. One timeline per (trader, market). */
@@ -5938,8 +6690,10 @@ export interface OperationQuery {
         event?: string;
         /** Optional per-connection subscribe-time filter. Raw provider condition_id or mkt_-prefixed market id (normalized the same way the other v1 market endpoints normalize). A frame passes only when it carries a matching condition_id field; frames that carry no condition_id (e.g. whale-pulse events) are EXCLUDED while this is set. An empty value after normalization returns HTTP 400. Combines with event and min_grade as a logical AND; an absent param adds no constraint. */
         condition_id?: string;
-        /** Optional per-connection subscribe-time filter. A frame passes only when it carries a grade field whose grade is better-or-equal to this minimum (S is best). Frames without a grade (every frame except wallet_grade_changed and LargeTradeInsertedV2) are excluded. An invalid grade returns HTTP 400. Combines with the other filters as a logical AND. */
+        /** Optional per-connection subscribe-time filter. A frame passes only when it carries a grade field whose grade is better-or-equal to this minimum (S is best). On a LargeTradeInsertedV2 frame that field is grade, the wallet's grade when the trade was published: seconds after the fill for a live trade, hours after it for a backfilled one, so it is not always the grade the trade filled under. For that, send min_grade_at_trade instead. Frames without a grade (every frame except wallet_grade_changed and LargeTradeInsertedV2) are excluded. An invalid grade returns HTTP 400. Combines with the other filters as a logical AND. */
         min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Filter LargeTradeInsertedV2 frames to trades whose grade_at_trade, the grade the trader held when the trade filled, is at or above this minimum (S is best). Only a frame whose grade_at_trade_status is graded can match. The same basis as min_grade_at_trade on GET /api/v1/large-trades and on webhook trade_filters. Other event types are excluded when set. Sending it with min_grade, or an invalid grade, returns HTTP 400. */
+        min_grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F";
         /** Filter LargeTradeInsertedV2 frames to this Polymarket wallet. Other event types have no wallet and are excluded when set. Applied to live and retained Redis frames after privacy checks. */
         wallet?: string;
         /** Filter LargeTradeInsertedV2 frames to trades at or above this USD notional. Positive decimal with at most six places; other event types are excluded when set. */
@@ -5955,7 +6709,7 @@ export interface OperationQuery {
         max_age_s?: number;
     };
     getTraderCategoryRecords: {
-        /** Filter to one canonical category, matched through the same rollup every other category surface uses: soccer, EPL and champions league all reach Soccer, every esports label folds into Esports, and football is AMERICAN football and reaches Football. A filter that reaches Esports returns the Esports record with all of its games; a game is not a filter of its own, so ask for esports and read games. A sports or esports category the wallet has no record in answers 200 with an empty records array, never 404. Sports and esports only (#27311): a category outside them, or a value that reaches no category, returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter to one canonical category, matched through the same rollup every other category surface uses: soccer, EPL and champions league all reach Soccer, every esports label folds into Esports, and football is AMERICAN football and reaches Football. A filter that reaches Esports returns the Esports record with all of its games; a game is not a filter of its own, so ask for esports and read games. A sports or esports category the wallet has no record in answers 200 with an empty records array, never 404. Sports and esports only (#27311): a category outside them, or a value that reaches no category, returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). */
         category?: string;
     };
     getTraderContext: Record<string, never>;
@@ -6076,7 +6830,7 @@ export interface OperationQuery {
         cursor?: string;
         /** Minimum position value in USD. Raises the feed's own floor of 50,000 USD; a smaller value does not lower it. */
         min_size?: number;
-        /** One RFC 4180 CSV record of exact current provider-backed market_canonical.category values. Legacy unquoted lists such as NBA,WNBA remain valid; values containing commas, quotes, or newlines are CSV-quoted. Matching is case-insensitive. Malformed quoted input fails closed as one unknown exact category. A value outside sports and esports returns 400 bad_request with param=category (#27305), as on GET /api/v1/markets/explore. */
+        /** One RFC 4180 CSV record of exact current provider-backed market_canonical.category values. Legacy unquoted lists such as NBA,WNBA remain valid; values containing commas, quotes, or newlines are CSV-quoted. Matching is case-insensitive. Malformed quoted input fails closed as one unknown exact category. A value outside sports and esports returns 400 bad_request with param=category (#27305), as on GET /api/v1/markets/explore. The word sports, in any casing, names every sport and returns 400 bad_request with param category, because this filter takes one category: omit category for every sports and esports market, or name one sport (#32657). */
         category?: string;
         /** Minimum trader grade. Matched against the trader.grade each row returns, the wallet's current grade, so every row listed shows a grade at or above this floor. */
         min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
@@ -6110,10 +6864,12 @@ export interface OperationQuery {
         condition_id?: string;
         /** Trader wallet address, timestamp-suffixed wallet alias, username, or trd_-prefixed trader ID, resolved against the traders table. Unknown traders return an empty list. */
         trader?: string;
-        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27430): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27430): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). */
         category?: string;
-        /** Minimum trader grade as of today (trader.grade), not at trade time. On a historical window it selects wallets by a grade they may have earned after the trade; for a point-in-time rule filter on trader.grade_at_trade instead. A means S or A, B means S, A or B. */
+        /** Minimum trader grade as of today (trader.grade), not at trade time. On a historical window it selects wallets by a grade they may have earned after the trade; for a point-in-time rule send min_grade_at_trade instead, which filters on trader.grade_at_trade. A means S or A, B means S, A or B. */
         min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Minimum grade the trader held when the trade filled (trader.grade_at_trade). Only rows whose trader.grade_at_trade_status is graded can match, so a trade before 2026-09-19T23:00Z, or one made while the wallet's grade was changing, never does. The same basis as min_grade_at_trade on GET /api/v1/large-trades, GET /api/v1/stream and webhook trade_filters, so a history read and a stream with the same floor agree. Applies to both sorts and beside condition_id, event_slug, trader and from/to. Sending it with min_grade is 400. A means S or A, B means S, A or B. */
+        min_grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F";
         /** When true, return only rows with persisted suspicion_score >= 60. The filter is applied before SQL-backed limit + 1 pagination. */
         suspicious_only?: boolean;
         /** Filter by whale_alerts.platform. all is equivalent to omitted. */
@@ -6136,10 +6892,12 @@ export interface OperationQuery {
         cursor?: string;
         /** Minimum trade size in USD. */
         min_size?: number;
-        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27430): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27430): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). */
         category?: string;
-        /** Minimum trader grade. */
+        /** Minimum trader grade now (trader.grade), the wallet's grade when this page is read, not when the trade filled. A wallet re-graded after a trade enters or leaves the result, so a catch-up read can disagree with GET /api/v1/stream and webhooks. For the grade at the fill, send min_grade_at_trade instead. A means S or A, B means S, A or B. */
         min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Minimum grade the trader held when the trade filled (trader.grade_at_trade). Only rows whose trader.grade_at_trade_status is graded can match, so a trade before 2026-09-19T23:00Z, or one made while the wallet's grade was changing, never does. The same basis as min_grade_at_trade on GET /api/v1/stream and on webhook trade_filters, so a client that catches up here and then streams gets one answer. Applies to every path: recent, since, sort=market_volume_share, condition_id and event_slug. Sending it with min_grade is 400. A means S or A, B means S, A or B. */
+        min_grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F";
         /** When true, return only rows with persisted suspicion_score >= 60. The filter is applied before SQL-backed limit + 1 pagination. */
         suspicious_only?: boolean;
         /** Keep only trades whose market_volume_share is known and at least this. A fraction, not a percent: 0.01 is one percent of the market's traded volume. A trade whose share is unavailable is never returned by a non-zero value, because an unavailable share cannot be said to clear a floor. */
@@ -6158,7 +6916,7 @@ export interface OperationQuery {
         limit?: number;
         /** Opaque lbv1_ pagination cursor from a prior response. It binds the finite score/address boundary to the committed leaderboard generation and the effective category/strategy filters, and on a sorted page to its sort, dir and activity. A cursor from another sort or dir is a 400 bad_request on cursor; one from another activity, category, strategy or generation is cursor_expired. Legacy, malformed, non-finite, and unsupported-version cursors are rejected. */
         cursor?: string;
-        /** Filter by category: a sport or esports bucket. Values are matched to canonical category buckets: league values fold into their sport (NBA and NCAAB into Basketball, NFL into Football). Mapped buckets are case-insensitive; passthrough buckets (Cricket, Sports) match case-sensitively against the provider-native bucket key, so use exact casing. Sports and esports only (#27306): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by category: a sport or esports bucket, matched case-insensitively. League values fold into their sport (NBA and NCAAB into Basketball, NFL into Football). Sports and esports only (#27306): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). */
         category?: string;
         /** Filter by observed trading style. Current styles: two_sided, category_focused, high_activity, diversified, mixed, unclassified. Current styles count the wallet's sports and esports markets only. The ten archetype keys retired on 2026-10-01 (accumulator, algo_trader, arbitrageur, directional, event_driven, market_maker, momentum, scalper, speculator, swing_trader) are still accepted and match no wallet. Style describes recorded behavior; grade measures performance. */
         strategy?: "category_focused" | "diversified" | "high_activity" | "mixed" | "two_sided" | "unclassified";
@@ -6179,7 +6937,7 @@ export interface OperationQuery {
         consistency?: "live" | "snapshot";
         /** Minimum current position value in USD. Defaults to 100 when omitted, or to 0 when wallet is present; send 0 to include every reconciled position. */
         min_size?: number;
-        /** Exact match against provider-backed market_canonical.category. Sports and esports only (#27311): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Exact match against provider-backed market_canonical.category. Sports and esports only (#27311): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, names every sport and returns 400 bad_request with param category, because this filter takes one category: omit category for every sports and esports market, or name one sport (#32657). */
         category?: string;
         /** Scope to one market. Accepts the raw provider condition_id or the mkt_-prefixed market id emitted by V1 responses. Combine with min_size=0 for every reconciled position in that market; an unknown id or a resolved market returns []. A market outside sports and esports returns 404 not_found with error.reason=market_out_of_scope (#27311). Without condition_id the board and wallet reads list sports and esports markets only. */
         condition_id?: string;
@@ -6199,7 +6957,7 @@ export interface OperationQuery {
         limit?: number;
         /** Opaque cursor from previous response's next_cursor. Encodes the first-page as_of timestamp, normalized effective filters, ranking and aggregate collection revisions, plus the last row's absolute net flow and condition_id. A changed filter or collection returns cursor_expired; request the first page again. */
         cursor?: string;
-        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27306): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27306): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). */
         category?: string;
         /** Filter by source platform. all is a request-side no-op. */
         platform?: "polymarket" | "all";
@@ -6219,7 +6977,7 @@ export interface OperationQuery {
         limit?: number;
         /** Opaque cursor from previous response's next_cursor. Encodes the first-page as_of timestamp, normalized effective filters, ranking and aggregate collection revisions, plus the last row's absolute net flow and condition_id. A changed filter or collection returns cursor_expired; request the first page again. */
         cursor?: string;
-        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27306): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27306): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). */
         category?: string;
         /** Filter by source platform. all is a request-side no-op. */
         platform?: "polymarket" | "all";
@@ -6287,10 +7045,12 @@ export interface OperationQuery {
         condition_id?: string;
         /** Trader wallet address, timestamp-suffixed wallet alias, or username resolved against the traders table. Unknown traders return an empty list. */
         trader?: string;
-        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27430): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27430): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). */
         category?: string;
         /** Minimum trader grade. */
         min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Minimum grade the trader held when the trade filled (trader.grade_at_trade). Only rows whose trader.grade_at_trade_status is graded can match, so a trade before 2026-09-19T23:00Z, or one made while the wallet's grade was changing, never does. The same basis as min_grade_at_trade on GET /api/v1/large-trades, GET /api/v1/stream and webhook trade_filters, so a history read and a stream with the same floor agree. Applies to both sorts and beside condition_id, event_slug, trader and from/to. Sending it with min_grade is 400. A means S or A, B means S, A or B. */
+        min_grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F";
         /** When true, return only rows with persisted suspicion_score >= 60. The filter is applied before SQL-backed limit + 1 pagination. */
         suspicious_only?: boolean;
         /** Filter by whale_alerts.platform. all is equivalent to omitted. */
@@ -6313,10 +7073,12 @@ export interface OperationQuery {
         cursor?: string;
         /** Minimum trade size in USD. */
         min_size?: number;
-        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27430): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by market category (case-insensitive). A canonical bucket name (e.g. Basketball) matches every provider member that folds into it (NBA, WNBA, NCAAB); a raw provider value also resolves to its bucket. Sports and esports only (#27430): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, matches every sport but Esports, the provider's catch-all Sports category (cycling, lacrosse) included: use esports for Esports alone, or omit category for both (#32657). */
         category?: string;
-        /** Minimum trader grade as of today (trader.grade). A means S or A, B means S, A or B. */
+        /** Minimum trader grade now (trader.grade), the wallet's grade when this page is read, not when the trade filled. A wallet re-graded after a trade enters or leaves the result, so a catch-up read can disagree with GET /api/v1/stream and webhooks. For the grade at the fill, send min_grade_at_trade instead. A means S or A, B means S, A or B. */
         min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Minimum grade the trader held when the trade filled (trader.grade_at_trade). Only rows whose trader.grade_at_trade_status is graded can match, so a trade before 2026-09-19T23:00Z, or one made while the wallet's grade was changing, never does. The same basis as min_grade_at_trade on GET /api/v1/stream and on webhook trade_filters, so a client that catches up here and then streams gets one answer. Applies to every path: recent, since, sort=market_volume_share, condition_id and event_slug. Sending it with min_grade is 400. A means S or A, B means S, A or B. */
+        min_grade_at_trade?: "S" | "A" | "B" | "C" | "D" | "F";
         /** When true, return only rows with persisted suspicion_score >= 60. The filter is applied before SQL-backed limit + 1 pagination. */
         suspicious_only?: boolean;
         /** Keep only trades whose market_volume_share is known and at least this. A fraction, not a percent: 0.01 is one percent of the market's traded volume. A trade whose share is unavailable is never returned by a non-zero value, because an unavailable share cannot be said to clear a floor. */
@@ -6350,7 +7112,7 @@ export interface OperationQuery {
         cursor?: string;
         /** Filter by market status. A market is closed once Polymarket has closed trading or it has resolved, and active otherwise; all returns both. */
         status?: "active" | "closed" | "all";
-        /** Filter by category. Sports and esports only (#27411): a category outside them returns 400 bad_request with param category and names the accepted buckets. */
+        /** Filter by category. Sports and esports only (#27411): a category outside them returns 400 bad_request with param category and names the accepted buckets. The word sports, in any casing, names every sport and returns 400 bad_request with param category, because this filter takes one category: omit category for every sports and esports market, or name one sport (#32657). */
         category?: string;
     };
     submitTraderExport: {
@@ -7169,6 +7931,7 @@ export interface OperationResponse {
         /** Total matching rows when the read model exposes a count; the key is absent when it does not. */
         total?: number;
         meta: ResponseMeta;
+        summary?: LeaderboardSummary;
     };
     listLeaderboardLeagues: {
         object: "leaderboard_leagues";