@0xinsider/mcp 3.11.0 → 3.13.0

package/dist/sdk/schema.d.ts

@@ -51,6 +51,23 @@ export type AgentRegistration = {
         auth_guide_url: string;
     };
 };
+/** A computed count with its truth state; the same envelope as AnalyticNumber. */
+export type AnalyticInteger = {
+    state: "computed" | "known_zero" | "not_computed" | "not_applicable" | "stale" | "unavailable" | "insufficient_data";
+    source: "provider" | "insert_time" | "cache" | "computed";
+    value?: number;
+    freshness_at?: string;
+};
+/** A computed number with its truth state. value is present when state is computed or known_zero and may be present when stale; any other state says why there is no number, never a stand-in zero. */
+export type AnalyticNumber = {
+    /** computed: a measured value. known_zero: a measured zero. stale: a value past its freshness window. not_computed: an input is unknown. not_applicable: the measure does not apply. unavailable: the source could not be read. insufficient_data: too few observations. */
+    state: "computed" | "known_zero" | "not_computed" | "not_applicable" | "stale" | "unavailable" | "insufficient_data";
+    /** Where the value came from, for diagnostics: cache is a stored aggregate, computed a request-time aggregate. Decide on state, not source. */
+    source: "provider" | "insert_time" | "cache" | "computed";
+    value?: number;
+    /** When the stored inputs behind the value were written or last confirmed (cache), or the request time (computed). */
+    freshness_at?: string;
+};
 export type ApiDiscovery = {
     /** Canonical API origin for public V1 requests. */
     api_base_url: string;
@@ -984,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"[];
@@ -1330,10 +1348,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 = {
@@ -1793,7 +1813,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;
@@ -1807,20 +1827,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;
 };
@@ -1867,17 +1893,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. */
@@ -1895,6 +1932,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). */
@@ -2630,6 +2682,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). */
@@ -2725,6 +2784,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. */
@@ -2902,6 +3022,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 = {
@@ -2934,6 +3056,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 = {
@@ -2972,6 +3096,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 = {
@@ -3396,145 +3522,647 @@ 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 = {
-    /** Frozen pre-game price of the backed side, 0..1, as the plain decimal text of the stored NUMERIC at full stored precision, trailing zeros included -- rendered exactly as the commitment payload renders it. */
-    backed_price: string;
-    /** Provider condition id of the backed market. */
-    condition_id: string;
-    /** Frozen provider kickoff, UTC, literal Z; null when no kickoff was frozen. Whole seconds render exactly as the commitment payload does; a sub-second instant keeps its fraction rather than being truncated, since nothing here is hashed. */
-    kickoff: string | null;
-    /** ET product day (YYYY-MM-DD). */
-    pick_date: string;
-    /** Index of the backed outcome within the market. */
-    pick_outcome_index: 0 | 1;
-    /** Frozen display label of the backed outcome. */
-    pick_outcome_label: string;
-    /** 1-based daily slot. */
-    pick_rank: number;
-    /** Provider platform. Always polymarket. */
-    platform: "polymarket";
-};
-/** Provider-first sports context for a Pick of the Day market: team crests, league branding, and live score. Each team `logo` is a registered club crest or national flag as a same-origin path where one exists, and provider artwork otherwise. */
-export type PickSportsContext = {
-    /** League or competition display name (e.g. "Premier League"). */
-    league_name: string | null;
-    /** Provider-owned event taxonomy from Gamma eventMetadata, joined in league · serie · tournament order with blanks and case-insensitive duplicates removed. A tennis qualifying match ends in ", Qualification", including an ATP Challenger qualifying match, which Gamma marks only in eventMetadata.tennisFixtureSource. Separate from league_name; omitted when the provider does not supply the metadata. */
-    competition_label?: string;
-    /** League logo URL (provider-owned). */
-    league_logo: string | null;
-    /** The team mapped to the market's YES outcome, or the parent-event home/first team when event_matchup is true. */
-    yes_team: PickSportsTeam | null;
-    /** The team mapped to the market's NO outcome, or the parent-event away/second team when event_matchup is true. */
-    no_team: PickSportsTeam | null;
-    /** Provider game identifier (Polymarket Gamma gameId); omitted when the provider supplies none. */
-    game_id?: number;
-    /** Always present. True when the two teams are the parent-event match identity for a teamless binary leg (e.g. a draw, totals, or prop market), not the market's own outcomes. */
-    event_matchup: boolean;
-    /** Present only alongside event_matchup: the event team the binary leg is about (provider group_item_title matched to a matchup team, e.g. Belgium for "Will Belgium win?"), i.e. the winner on a Yes resolution. Omitted for teamless legs (draw, totals, prop). */
-    event_subject_team?: PickSportsTeam;
-    /** The two teams as a single whole-game label, joined "<home> – <away>" (en-dash) in provider display order (e.g. "Portugal – Uzbekistan"). Composed server-side from the provider team names (no title/slug parsing). Present when both teams resolve a name; omitted for single-subject, teamless, or non-two-team contexts. */
-    matchup_title?: string;
-};
-/** A single sports team or competitor in a Pick of the Day market's sports context. Identity and score fields are provider-owned and nullable. The structured score fields (`sets`, `format`, `sets_won`) and the tennis fields (`headshot`, `headshot_revision`, `tour`) are backend-owned and are OMITTED rather than null when they do not apply, so a consumer must treat an absent key and a null the same way. */
-export type PickSportsTeam = {
-    /** Team display label as it appears on the market outcome (e.g. "Portugal"). */
-    label: string | null;
-    /** Abbreviated team label (e.g. "POR"). */
-    short_label: string | null;
-    /** The name to show for this team or competitor, the same on every surface (e.g. "UCF Knights", "Oklahoma City Thunder", "Portugal"). `label` keeps the market outcome's own spelling. */
-    full_name: string | null;
-    /** Provider team identifier (Polymarket /teams id). */
-    provider_id: number | null;
-    /** Team crest or flag URL. Official NFL (32), WNBA (15), NBA (30), NHL (32), and MLB (30) club crests use same-origin relative paths (`/api/sports/team-logos/{league}/{abbr}.svg?v=<content hash>`); resolve relative URLs against the API origin. Vendored soccer club crests use the same path with `.png`. National teams in the registered national-team competitions use the same path with `.svg`: the official national flag, drawn whole at its own aspect. Other teams use provider artwork, including country flags for tennis players. Novelty rows, and national-team rows that are not exactly one country, retain provider artwork. */
-    logo: string | null;
-    /** True when artwork measurements show that the team mark needs a light plate on a dark background. Vendored crest verdicts are tied to the exact asset bytes; provider artwork is measured by the teams sync. Always sent; false when no current measurement marks the logo dark. */
-    logo_mark_dark: boolean;
-    /** Team brand color as a hex string (provider-owned). */
-    color: string | null;
-    /** Win-loss record as a display string (e.g. "12-4"). */
-    record: string | null;
-    /** Live or final score as a display string when the game is in play or settled. */
-    score: string | null;
-    /** Tennis player headshot URL, served same-origin. Present only for a tennis competitor the headshot resolver matched; absent for team sports and for unmatched players, where `logo` stays the fallback. */
-    headshot?: string;
-    /** Tennis tour this competitor belongs to. Present for every tennis entry whether or not `headshot` resolved, so a consumer can tell a tennis player with no photo from a non-tennis team. Absent for every other sport. Only `atp` and `wta` name a gender; the ITF World Tennis Tour runs men's and women's events and the provider does not say which, so `itf` means tennis with gender unknown. */
-    tour?: "atp" | "wta" | "itf";
-    /** Per-set score cells for this side, in set order. Backend-owned: render these rather than parsing `score`. Omitted entirely when the provider score is not a structured multi-set match or could not be parsed, so an absent array and an empty one carry the same meaning. */
-    sets?: ScoreCell[];
-    format?: ScoreFormat;
-    /** Completed sets won by this side. Present only when both sides expose the same set columns, so a partially parsed scoreline reports no tally rather than a misleading one. */
-    sets_won?: number;
-    /** Optional monotonic photo revision for this tennis player, independent of the sports score revision. Legacy stored photos start at zero. Successful new or changed image bytes advance it; source checks and attribution changes do not. Compare only for the same tour and provider_id: a higher revision replaces the portrait, an equal revision may fill a missing portrait, and a lower revision must not replace a newer one. Absent when no photo resolved. */
-    headshot_revision?: number;
-    /** Optional latest retrieved ATP/WTA singles rank for this player. Absent for unranked, ambiguous, doubles, expired, or unavailable identities. This is not rank at match time. */
-    ranking?: TennisRanking;
-    /** True when artwork measurements show that the team mark disappears on a white background and needs a dark plate there: the light-background twin of logo_mark_dark. Vendored crest verdicts are tied to the exact asset bytes; provider artwork is measured on white by the teams sync. Always sent; false when no current measurement marks the logo light. */
-    logo_mark_light: boolean;
-    /** True when logo_mark_dark and logo_mark_light are both measurements of this exact logo URL, so their false means the mark is legible on that background. Every vendored crest is measured; a provider logo is measured once the teams sync has scored it, usually within a few hourly cycles of first appearing. Always sent; false while the logo is not measured yet. */
-    logo_mark_measured: boolean;
-};
-export type PlatformCapabilities = {
-    grade: PlatformCapabilityStatus;
-    pnl: PlatformCapabilityStatus;
-    strategy: PlatformCapabilityStatus;
-    timeline: PlatformCapabilityStatus;
-    /** The large-trade feed. Canonical key since #16304; whale_signal is its deprecated spelling, emitted beside it with the same value until its sunset on 2027-02-01 (#29352). */
-    large_trades: PlatformCapabilityStatus;
-    /**
-     * Deprecated spelling of large_trades, emitted beside it with the same value. Sunset 2027-02-01 (#29352): removed from V1 on that date; read large_trades.
-     * @deprecated
-     */
-    whale_signal: PlatformCapabilityStatus;
-    suspicious_trades: PlatformCapabilityStatus;
-    /**
-     * Deprecated spelling of suspicious_trades, emitted beside it with the same value. Sunset 2027-02-01 (#29352): removed from V1 on that date; read suspicious_trades.
-     * @deprecated
-     */
-    insider_radar: PlatformCapabilityStatus;
-    market_snapshot: PlatformCapabilityStatus;
-};
-/** Every capability the API serves reports supported. The field names a per-capability status so a client can branch on coverage; no other value is emitted. */
-export type PlatformCapabilityStatus = "supported";
-export type Platforms = {
-    platforms: {
-        polymarket: PlatformCapabilities;
+/** 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;
+        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?: {
+        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;
     };
-};
-/** A derived 0xinsider correction to Polymarket's P&L, never a Polymarket value. Polymarket misbooks neg-risk conversions, in both directions: it puts cost on placeholder YES outcomes minted by a conversion and never books it as a loss (negative amount), and its position records leave out shares the wallet really got, such as YES minted by a conversion, so it books no P&L on them (positive amount). Per neg-risk market the wallet converted in, 0xinsider measures Polymarket's own activity cash against the sum of its position P&L, and sums the difference over every measured market whose shares did not move by direct transfer: transferred shares have no activity row, so such a market keeps Polymarket's figure and is counted in markets_excluded. It is published once every neg-risk market with a sports or esports event that the wallet converted in is measured and checked for transfers, and stays as last published until then; a market with no sports or esports event is not measured, and counts only when it was measured before (on the trader body, pnl.correction_pending says so); a sum under $1 either way publishes nothing. The body's own P&L fields keep Polymarket's figures; this object adds the amount and the corrected figures. Money is truncated toward zero to cents. */
-export type PnlCorrection = {
-    /** The correction method. */
-    basis: "neg_risk_conversion_v1";
-    /** The correction in USD. Negative when Polymarket overstates the wallet. */
-    amount: number;
-    /** Polymarket's net realized P&L plus amount. Since 2026-10-22 the grade reads this figure's sports and esports share. Omitted when Polymarket's figure is. */
-    realized?: number;
-    /** Polymarket's net total P&L over every Polymarket market of the wallet, plus amount. Omitted when Polymarket's figure is, and on leaderboard entries. */
-    net_total?: number;
-    /** The newest measurement among the measured markets. */
-    as_of: string;
-    /** Neg-risk markets whose measurement amount sums. */
-    markets_measured: number;
-    /** Measured neg-risk markets left out because shares moved in or out of the wallet by direct transfer; they keep Polymarket's figure. Omitted when none. */
-    markets_excluded?: number;
-};
-export type Position = {
-    /** Composite prefixed ID `pos_<wallet>:<condition_id>:<outcome_index>`. */
-    id: string;
-    /** Provider discriminator. Polymarket only. */
-    platform: "polymarket";
-    /** Lowercased proxy wallet address. */
-    wallet: string;
-    /** Binary outcome side. Non-binary positions are not surfaced on V1. */
-    side: "YES" | "NO";
-    /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for this outcome; null when unavailable (e.g. unsynced markets). */
-    token_id: string | null;
-    /** Live share count from the wallet_positions mirror. */
-    shares: number;
-    /** Volume-weighted entry price for this leg. */
-    avg_price?: number;
-    /** Current mark-to-market value in USD (always non-null on V1 — pre-reconcile rows are excluded). */
+    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;
+        };
+    };
+    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;
+        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;
+    }[];
+    view: string;
+    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;
+    }[];
+};
+/** 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 = {
+    /** Frozen pre-game price of the backed side, 0..1, as the plain decimal text of the stored NUMERIC at full stored precision, trailing zeros included -- rendered exactly as the commitment payload renders it. */
+    backed_price: string;
+    /** Provider condition id of the backed market. */
+    condition_id: string;
+    /** Frozen provider kickoff, UTC, literal Z; null when no kickoff was frozen. Whole seconds render exactly as the commitment payload does; a sub-second instant keeps its fraction rather than being truncated, since nothing here is hashed. */
+    kickoff: string | null;
+    /** ET product day (YYYY-MM-DD). */
+    pick_date: string;
+    /** Index of the backed outcome within the market. */
+    pick_outcome_index: 0 | 1;
+    /** Frozen display label of the backed outcome. */
+    pick_outcome_label: string;
+    /** 1-based daily slot. */
+    pick_rank: number;
+    /** Provider platform. Always polymarket. */
+    platform: "polymarket";
+};
+/** Provider-first sports context for a Pick of the Day market: team crests, league branding, and live score. Each team `logo` is a registered club crest or national flag as a same-origin path where one exists, and provider artwork otherwise. */
+export type PickSportsContext = {
+    /** League or competition display name (e.g. "Premier League"). */
+    league_name: string | null;
+    /** Provider-owned event taxonomy from Gamma eventMetadata, joined in league · serie · tournament order with blanks and case-insensitive duplicates removed. A tennis qualifying match ends in ", Qualification", including an ATP Challenger qualifying match, which Gamma marks only in eventMetadata.tennisFixtureSource. Separate from league_name; omitted when the provider does not supply the metadata. */
+    competition_label?: string;
+    /** League logo URL (provider-owned). */
+    league_logo: string | null;
+    /** The team mapped to the market's YES outcome, or the parent-event home/first team when event_matchup is true. */
+    yes_team: PickSportsTeam | null;
+    /** The team mapped to the market's NO outcome, or the parent-event away/second team when event_matchup is true. */
+    no_team: PickSportsTeam | null;
+    /** Provider game identifier (Polymarket Gamma gameId); omitted when the provider supplies none. */
+    game_id?: number;
+    /** Always present. True when the two teams are the parent-event match identity for a teamless binary leg (e.g. a draw, totals, or prop market), not the market's own outcomes. */
+    event_matchup: boolean;
+    /** Present only alongside event_matchup: the event team the binary leg is about (provider group_item_title matched to a matchup team, e.g. Belgium for "Will Belgium win?"), i.e. the winner on a Yes resolution. Omitted for teamless legs (draw, totals, prop). */
+    event_subject_team?: PickSportsTeam;
+    /** The two teams as a single whole-game label, joined "<home> – <away>" (en-dash) in provider display order (e.g. "Portugal – Uzbekistan"). Composed server-side from the provider team names (no title/slug parsing). Present when both teams resolve a name; omitted for single-subject, teamless, or non-two-team contexts. */
+    matchup_title?: string;
+};
+/** A single sports team or competitor in a Pick of the Day market's sports context. Identity and score fields are provider-owned and nullable. The structured score fields (`sets`, `format`, `sets_won`) and the tennis fields (`headshot`, `headshot_revision`, `tour`) are backend-owned and are OMITTED rather than null when they do not apply, so a consumer must treat an absent key and a null the same way. */
+export type PickSportsTeam = {
+    /** Team display label as it appears on the market outcome (e.g. "Portugal"). */
+    label: string | null;
+    /** Abbreviated team label (e.g. "POR"). */
+    short_label: string | null;
+    /** The name to show for this team or competitor, the same on every surface (e.g. "UCF Knights", "Oklahoma City Thunder", "Portugal"). `label` keeps the market outcome's own spelling. */
+    full_name: string | null;
+    /** Provider team identifier (Polymarket /teams id). */
+    provider_id: number | null;
+    /** Team crest or flag URL. Official NFL (32), WNBA (15), NBA (30), NHL (32), and MLB (30) club crests use same-origin relative paths (`/api/sports/team-logos/{league}/{abbr}.svg?v=<content hash>`); resolve relative URLs against the API origin. Vendored soccer club crests use the same path with `.png`. National teams in the registered national-team competitions use the same path with `.svg`: the official national flag, drawn whole at its own aspect. Other teams use provider artwork, including country flags for tennis players. Novelty rows, and national-team rows that are not exactly one country, retain provider artwork. */
+    logo: string | null;
+    /** True when artwork measurements show that the team mark needs a light plate on a dark background. Vendored crest verdicts are tied to the exact asset bytes; provider artwork is measured by the teams sync. Always sent; false when no current measurement marks the logo dark. */
+    logo_mark_dark: boolean;
+    /** Team brand color as a hex string (provider-owned). */
+    color: string | null;
+    /** Win-loss record as a display string (e.g. "12-4"). */
+    record: string | null;
+    /** Live or final score as a display string when the game is in play or settled. */
+    score: string | null;
+    /** Tennis player headshot URL, served same-origin. Present only for a tennis competitor the headshot resolver matched; absent for team sports and for unmatched players, where `logo` stays the fallback. */
+    headshot?: string;
+    /** Tennis tour this competitor belongs to. Present for every tennis entry whether or not `headshot` resolved, so a consumer can tell a tennis player with no photo from a non-tennis team. Absent for every other sport. Only `atp` and `wta` name a gender; the ITF World Tennis Tour runs men's and women's events and the provider does not say which, so `itf` means tennis with gender unknown. */
+    tour?: "atp" | "wta" | "itf";
+    /** Per-set score cells for this side, in set order. Backend-owned: render these rather than parsing `score`. Omitted entirely when the provider score is not a structured multi-set match or could not be parsed, so an absent array and an empty one carry the same meaning. */
+    sets?: ScoreCell[];
+    format?: ScoreFormat;
+    /** Completed sets won by this side. Present only when both sides expose the same set columns, so a partially parsed scoreline reports no tally rather than a misleading one. */
+    sets_won?: number;
+    /** Optional monotonic photo revision for this tennis player, independent of the sports score revision. Legacy stored photos start at zero. Successful new or changed image bytes advance it; source checks and attribution changes do not. Compare only for the same tour and provider_id: a higher revision replaces the portrait, an equal revision may fill a missing portrait, and a lower revision must not replace a newer one. Absent when no photo resolved. */
+    headshot_revision?: number;
+    /** Optional latest retrieved ATP/WTA singles rank for this player. Absent for unranked, ambiguous, doubles, expired, or unavailable identities. This is not rank at match time. */
+    ranking?: TennisRanking;
+    /** True when artwork measurements show that the team mark disappears on a white background and needs a dark plate there: the light-background twin of logo_mark_dark. Vendored crest verdicts are tied to the exact asset bytes; provider artwork is measured on white by the teams sync. Always sent; false when no current measurement marks the logo light. */
+    logo_mark_light: boolean;
+    /** True when logo_mark_dark and logo_mark_light are both measurements of this exact logo URL, so their false means the mark is legible on that background. Every vendored crest is measured; a provider logo is measured once the teams sync has scored it, usually within a few hourly cycles of first appearing. Always sent; false while the logo is not measured yet. */
+    logo_mark_measured: boolean;
+};
+export type PlatformCapabilities = {
+    grade: PlatformCapabilityStatus;
+    pnl: PlatformCapabilityStatus;
+    strategy: PlatformCapabilityStatus;
+    timeline: PlatformCapabilityStatus;
+    /** The large-trade feed. Canonical key since #16304; whale_signal is its deprecated spelling, emitted beside it with the same value until its sunset on 2027-02-01 (#29352). */
+    large_trades: PlatformCapabilityStatus;
+    /**
+     * Deprecated spelling of large_trades, emitted beside it with the same value. Sunset 2027-02-01 (#29352): removed from V1 on that date; read large_trades.
+     * @deprecated
+     */
+    whale_signal: PlatformCapabilityStatus;
+    suspicious_trades: PlatformCapabilityStatus;
+    /**
+     * Deprecated spelling of suspicious_trades, emitted beside it with the same value. Sunset 2027-02-01 (#29352): removed from V1 on that date; read suspicious_trades.
+     * @deprecated
+     */
+    insider_radar: PlatformCapabilityStatus;
+    market_snapshot: PlatformCapabilityStatus;
+};
+/** Every capability the API serves reports supported. The field names a per-capability status so a client can branch on coverage; no other value is emitted. */
+export type PlatformCapabilityStatus = "supported";
+export type Platforms = {
+    platforms: {
+        polymarket: PlatformCapabilities;
+    };
+};
+/** A derived 0xinsider correction to Polymarket's P&L, never a Polymarket value. Polymarket misbooks neg-risk conversions, in both directions: it puts cost on placeholder YES outcomes minted by a conversion and never books it as a loss (negative amount), and its position records leave out shares the wallet really got, such as YES minted by a conversion, so it books no P&L on them (positive amount). Per neg-risk market the wallet converted in, 0xinsider measures Polymarket's own activity cash against the sum of its position P&L, and sums the difference over every measured market whose shares did not move by direct transfer: transferred shares have no activity row, so such a market keeps Polymarket's figure and is counted in markets_excluded. It is published once every neg-risk market with a sports or esports event that the wallet converted in is measured and checked for transfers, and stays as last published until then; a market with no sports or esports event is not measured, and counts only when it was measured before (on the trader body, pnl.correction_pending says so); a sum under $1 either way publishes nothing. The body's own P&L fields keep Polymarket's figures; this object adds the amount and the corrected figures. Money is truncated toward zero to cents. */
+export type PnlCorrection = {
+    /** The correction method. */
+    basis: "neg_risk_conversion_v1";
+    /** The correction in USD. Negative when Polymarket overstates the wallet. */
+    amount: number;
+    /** Polymarket's net realized P&L plus amount. Since 2026-10-22 the grade reads this figure's sports and esports share. Omitted when Polymarket's figure is. */
+    realized?: number;
+    /** Polymarket's net total P&L over every Polymarket market of the wallet, plus amount. Omitted when Polymarket's figure is, and on leaderboard entries. */
+    net_total?: number;
+    /** The newest measurement among the measured markets. */
+    as_of: string;
+    /** Neg-risk markets whose measurement amount sums. */
+    markets_measured: number;
+    /** Measured neg-risk markets left out because shares moved in or out of the wallet by direct transfer; they keep Polymarket's figure. Omitted when none. */
+    markets_excluded?: number;
+};
+export type Position = {
+    /** Composite prefixed ID `pos_<wallet>:<condition_id>:<outcome_index>`. */
+    id: string;
+    /** Provider discriminator. Polymarket only. */
+    platform: "polymarket";
+    /** Lowercased proxy wallet address. */
+    wallet: string;
+    /** Binary outcome side. Non-binary positions are not surfaced on V1. */
+    side: "YES" | "NO";
+    /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for this outcome; null when unavailable (e.g. unsynced markets). */
+    token_id: string | null;
+    /** Live share count from the wallet_positions mirror. */
+    shares: number;
+    /** Volume-weighted entry price for this leg. */
+    avg_price?: number;
+    /** Current mark-to-market value in USD (always non-null on V1 — pre-reconcile rows are excluded). */
     current_value_usd: number;
     initial_value_usd?: number;
     /** Unrealized P&L for the open position (Polymarket `cashPnl`). */
@@ -3983,48 +4611,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 = {
@@ -4226,6 +4894,18 @@ export type Trader = {
     /** Current evidence for observed and known categories (expand=categories or expand[]=categories). Omitted unless expanded. Includes insufficient, stale, unknown and degraded rows; absence of a category is not proof of skill. The global grade is unchanged. Sports and esports only (#28827): a category outside them is omitted, as on GET /api/v1/trader/{address}/categories. */
     category_records?: CategorySkillV2[];
     category_skill_model?: CategorySkillModelReadiness;
+    /** Edge over the price paid: the profile's Edge badge and the leaderboard's Edge measure (#32622). Present on every read of a wallet with at least one settled sports or esports market of $20 or more at a known entry price; omitted for a wallet with none, where there is nothing to measure. */
+    price_edge?: TraderPriceEdge;
+    /** The profile's strategy measures over the wallet's sports and esports markets: P&L and win rate by UTC hour, hold-time and first-trade-hour bands, position sizes with category concentration, and entry-price buckets (#32622). Present only when expand=breakdowns or expand[]=breakdowns is requested, on GET /api/v1/trader/{address} only: POST /api/v1/traders/batch refuses the expand. Computed on the read from the wallet's whole sports and esports history, so a large wallet can take seconds; a read that cannot finish answers 503 with Retry-After. */
+    breakdowns?: TraderBreakdowns;
+};
+/** The profile's strategy measures (expand=breakdowns, #32622), the same figures as the wallet profile's Insights and Performance breakdown cards. Every figure counts the wallet's sports and esports markets only, from the same read the profile makes. */
+export type TraderBreakdowns = {
+    hourly_performance: TraderHourlyPerformance;
+    time_breakdowns: TraderTimeBreakdowns;
+    /** Position sizes and category concentration. null when the wallet has no sports or esports position with trades, or its stored markets carry no freshness clock yet. */
+    risk_metrics: TraderRiskMetrics | null;
+    entry_price_analysis: TraderEntryPriceAnalysis;
 };
 export type TraderCategoryRecord = {
     /** Canonical category bucket, for example Soccer, Esports, Tennis. Esports is one bucket, and the Esports record carries its per-game records in games. */
@@ -4297,6 +4977,56 @@ 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 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[];
+    /** The bucket with the highest win rate among buckets of at least 3 markets. null when no bucket has 3. */
+    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.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;
+    /** Markets in the band. */
+    markets: AnalyticInteger;
+    /** Of those, the markets that made money. */
+    wins: AnalyticInteger;
+    /** wins over decided markets (a nonzero P&L), as a percentage 0-100. */
+    win_rate: AnalyticNumber;
+    /** Realized P&L of the band's markets, USD. */
+    total_pnl: AnalyticNumber;
+    /** 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;
@@ -4470,6 +5200,36 @@ export type TraderGradeAt = {
         source_observed_by: string | null;
     } | null;
 };
+/** P&L and win rate by the UTC hour of the wallet's first trade in each settled sports or esports market. */
+export type TraderHourlyPerformance = {
+    /** One entry per UTC hour that has a settled market; an hour with none is absent. */
+    entries: ({
+        /** UTC hour of the first trade, 0-23. */
+        hour: number;
+        /** Settled markets first traded in this hour. */
+        markets: number;
+        /** Of those, the markets that made money at settlement. */
+        wins: number;
+        /** wins over the decided markets (settled with a nonzero P&L), as a percentage 0-100. 0 when no market of the hour is decided: read it with wins and markets. */
+        win_rate: number;
+        /** Realized P&L of those markets, USD. */
+        total_pnl: number;
+        /** total_pnl over markets, USD. */
+        avg_pnl: number;
+    })[];
+    /** The hour with the highest win_rate. null when no entry exists. */
+    best_hour: number | null;
+    /** best_hour's win_rate, percentage 0-100. null exactly when best_hour is. */
+    best_win_rate: number | null;
+    /** The hour with the lowest win_rate. null when no entry exists. */
+    worst_hour: number | null;
+    /** worst_hour's win_rate, percentage 0-100. null exactly when worst_hour is. */
+    worst_win_rate: number | null;
+    /** best_win_rate minus worst_win_rate, percentage points. null when either is null. */
+    spread_pp: number | null;
+    /** true when at least 12 hours have markets and every one of them has the same P&L sign, so the hour-to-hour spread says little about timing. */
+    is_approximate: boolean;
+};
 /** A trader's sports and esports daily P&L object. `id`, `freshness_at`, `series_status` and `realized` are always present. The five sections -- `entries`, `stats`, `monthly`, `year_totals`, `drawdown` -- are present unless the request's `sections` parameter excluded them, so a request that sends no `sections` always carries all five. An excluded section is absent from the object, never null and never an empty array. While `series_status` is `pending` the sections are empty and never mean zero. */
 export type TraderPnl = {
     /** Prefixed trader ID (`trd_...`). */
@@ -4623,6 +5383,40 @@ export type TraderPnlInScope = {
     /** When the record behind these figures was computed. */
     as_of: string;
 };
+/** Edge over the price paid (#32270, #32622): 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.012 is 1.2 percentage points. The same figures as LeaderboardPriceEdge, plus the shrunk edge the profile badge and the leaderboard show. No hold: a hold is a fact of a leaderboard row, not of the wallet. */
+export type TraderPriceEdge = {
+    /** Settled sports and esports markets of $20 or more at a known entry price that the edge is measured over. */
+    markets: number;
+    /** Share of those markets whose bought side won, 0-1. */
+    hit_rate: number;
+    /** Mean entry price paid, 0-1. */
+    avg_price: number;
+    /** hit_rate minus avg_price, full precision, before any shrink. */
+    edge: 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 over the same markets. 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. */
+    status: "ranked" | "too_few_markets" | "sample_mismatch";
+    /** The edge the profile badge shows and the leaderboard ranks: edge pulled toward field_average by how short the record is. A short record moves most of the way to the average; a long one keeps nearly all of its own edge. Present only when status is ranked. */
+    shrunk_edge?: number;
+    /** The mean edge of every ranked wallet that traded in the last 180 days, the value shrunk_edge is pulled toward. Present only with shrunk_edge. */
+    field_average?: number;
+};
+/** Position sizes over the wallet's sports and esports positions with trades, and how concentrated its volume is across categories. Each measure is an analytic value: read state before value. The four size measures are not_computed while any position's cost is unknown; the counts are always measured. */
+export type TraderRiskMetrics = {
+    /** Mean cost basis of a position, USD. */
+    avg_position_size: AnalyticNumber;
+    /** Median cost basis of a position, USD. */
+    median_position_size: AnalyticNumber;
+    /** Largest cost basis of a position, USD. */
+    max_position_size: AnalyticNumber;
+    /** Population standard deviation of the cost basis, USD. */
+    position_size_stddev: AnalyticNumber;
+    /** Sports and esports positions with trades. */
+    total_positions: number;
+    /** Positions whose cost is more than twice the mean. */
+    large_position_count: number;
+    /** Herfindahl index of the wallet's volume across sports and esports categories: each category's share of the volume, squared and summed. 1.0 is a single category; lower is more spread. not_computed while any category's cost is unknown, and no value without volume. */
+    concentration: AnalyticNumber;
+};
 /** Lossless counterparts for trader statistics. The object is present exactly when stats.total_volume is. */
 export type TraderStatsExact = {
     /** stats.total_volume as an exact decimal: the sports and esports USD volume, the sum of every stored trade day's `trader_trade_daily_rollups.in_scope_volume_total` (#29830). Polymarket's full-history wallet-wide user volume before 2026-10-27. */
@@ -4635,6 +5429,30 @@ export type TraderSyncedData = {
     /** Proxy wallet address. */
     wallet: string;
 };
+/** One band of a time breakdown. */
+export type TraderTimeBreakdownBand = {
+    /** The band's label. */
+    category_value: string;
+    /** Markets with a realized P&L in the band. */
+    n_markets: number;
+    /** Resolved markets that made money over resolved markets with a nonzero P&L, 0-1. null when none is decided. */
+    win_rate: number | null;
+    /** total_pnl over n_markets, USD. */
+    expectancy: number | null;
+    /** Gross profit over gross loss. null when the band has no loss. */
+    profit_factor: number | null;
+    /** Realized P&L of the band's markets, USD. */
+    total_pnl: number | null;
+};
+/** The hold-time and first-trade-hour bands of the profile's Performance breakdown card, over the wallet's sports and esports markets with a realized P&L. */
+export type TraderTimeBreakdowns = {
+    /** One row per band of time from the wallet's first to its last trade in a market: < 1h, 1h – 1d, 1 – 3d, 3 – 7d, 1 – 4w, > 4w. A band with no market is absent. */
+    by_duration: TraderTimeBreakdownBand[];
+    /** One row per four-hour UTC band of the wallet's first trade in a market: 00-03, 04-07, 08-11, 12-15, 16-19, 20-23. A band with no market is absent. */
+    by_hour_bucket: TraderTimeBreakdownBand[];
+    /** One-line summaries keyed by breakdown (by_duration, by_hour_bucket), from bands of at least 5 markets with a known P&L. A key is present only when there is a summary. */
+    insights: Record<string, string>;
+};
 /** Field-level trust metadata returned only when GET /api/v1/trader/{address} includes expand=trust. */
 export type TraderTrust = {
     /** Since 2026-10-27 always not_computed: pnl.total is retired and never sent (#29830). The key stays so the object keeps its shape. */
@@ -5254,11 +6072,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[];
@@ -5601,7 +6472,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";
@@ -5638,7 +6509,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";
@@ -5676,8 +6547,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. */
@@ -5744,11 +6617,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). */
@@ -5795,8 +6686,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. */
@@ -5804,15 +6697,15 @@ export interface OperationQuery {
     };
     getSuspiciousTrade: Record<string, never>;
     getTrader: {
-        /** Backward-compatible alias for expand. Repeatable: strategy, categories, trust. quant_metrics is accepted and returns nothing since 2026-10-27. */
-        "expand[]"?: ("strategy" | "categories" | "quant_metrics" | "trust")[];
-        /** Include heavy fields and trust metadata. Repeatable: strategy, categories, trust. quant_metrics is accepted and returns nothing since 2026-10-27. */
-        expand?: ("strategy" | "categories" | "quant_metrics" | "trust")[];
+        /** Backward-compatible alias for expand. Repeatable: strategy, categories, trust, breakdowns. quant_metrics is accepted and returns nothing since 2026-10-27. */
+        "expand[]"?: ("strategy" | "categories" | "quant_metrics" | "trust" | "breakdowns")[];
+        /** Include heavy fields and trust metadata. Repeatable: strategy, categories, trust, breakdowns. breakdowns adds the profile's strategy measures (Trader.breakdowns), computed on the read, and is served on this route only. quant_metrics is accepted and returns nothing since 2026-10-27. */
+        expand?: ("strategy" | "categories" | "quant_metrics" | "trust" | "breakdowns")[];
         /** Opt into a whole-response freshness ceiling in seconds. The server returns 200 only when data_quality.status is fresh or stale and data_quality.as_of is no older than this value; otherwise it returns 409 with error.reason=freshness_ceiling_unsatisfied. No refresh or alternate read is attempted. */
         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>;
@@ -5933,7 +6826,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";
@@ -5967,10 +6860,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. */
@@ -5993,10 +6888,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. */
@@ -6015,7 +6912,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";
@@ -6036,7 +6933,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;
@@ -6056,7 +6953,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";
@@ -6076,7 +6973,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";
@@ -6144,10 +7041,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. */
@@ -6170,10 +7069,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. */
@@ -6207,7 +7108,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: {
@@ -6500,7 +7401,7 @@ export interface OperationBody {
     batchGetTraders: {
         /** Trader identities to resolve in input order. */
         traders: string[];
-        /** Shared expand flags applied to every trader item. */
+        /** Shared expand flags applied to every trader item. breakdowns is refused with 400 (param expand): it computes on the read per wallet, so GET /api/v1/trader/{address} serves it one wallet at a time. */
         expand?: ("strategy" | "categories" | "quant_metrics" | "trust")[];
     };
     cancelTraderExport: never;
@@ -7026,6 +7927,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";