@0xinsider/mcp 1.2.3 → 2.0.0

package/dist/sdk/schema.d.ts

@@ -0,0 +1,2372 @@
+export type AccountIdentity = {
+    object: "account";
+    data: {
+        user_id: number;
+        credential_id: number;
+        credential_kind: "api_key" | "oauth_grant";
+        /** Approved OAuth scopes; null for full developer-key access. */
+        scopes: string[] | null;
+    };
+    meta: ResponseMeta;
+};
+/** A sandbox key and the path to live access (#13959). Nothing is stored: the key cannot be listed or revoked and does not expire. Register again for a new one. */
+export type AgentRegistration = {
+    /** The sandbox key. Send it as Authorization: Bearer <api_key> to the sandbox. The last 8 hex characters are a checksum (the first 4 bytes of SHA-256 over the rest of the key), so the sandbox can tell a mistyped key from a real one. It is not a secret and unlocks no production data. */
+    api_key: string;
+    /** Always false: this key never reaches live data. */
+    livemode: false;
+    environment: "sandbox";
+    created_at: string;
+    sandbox: {
+        /** The sandbox V1 base URL. Every documented operation answers here with example data. */
+        api_base_url: string;
+        /** A read to send with the key. */
+        first_request_url: string;
+        /** The OpenAPI document, served by the sandbox. */
+        openapi_url: string;
+    };
+    /** What live data needs, and where each credential comes from. Both need a person: an account with an active Pro subscription. */
+    live_access: {
+        /** The production V1 base URL. */
+        api_base_url: string;
+        /** What a live credential needs, in one sentence. */
+        requirement: string;
+        /** Where a signed-in Pro user creates a live key (oxi_sk_live_). */
+        api_keys_url: string;
+        /** RFC 8414 authorization server metadata, for an OAuth 2.1 grant the user approves. */
+        oauth_authorization_server_metadata_url: string;
+        /** RFC 7591 dynamic client registration for public OAuth clients. */
+        oauth_registration_endpoint: string;
+        /** The Pro plan. */
+        pricing_url: string;
+        /** The authentication walkthrough for agents. */
+        auth_guide_url: string;
+    };
+};
+export type ApiDiscovery = {
+    /** Canonical API origin for public V1 requests. */
+    api_base_url: string;
+    /** Full agent-readable API reference. */
+    docs_url: string;
+    /** Canonical web-origin OpenAPI JSON document. */
+    openapi_url: string;
+    /** Unauthenticated API health endpoint. */
+    health_url: string;
+    authentication: "Bearer API key required for data endpoints; discovery (/api/v1), health, /api/v1/platforms, and the MCP handshake (initialize, ping, tools/list on /api/v1/mcp) are public. A 401 carries WWW-Authenticate with the resource_metadata URL.";
+    /** RFC 9728 protected-resource metadata for the API origin: the document every V1 401 names in its WWW-Authenticate challenge (resource, bearer_methods_supported, resource_documentation). The remote MCP server has its own document at /.well-known/oauth-protected-resource/api/v1/mcp. */
+    protected_resource_metadata_url: string;
+    /** The complete authenticated route index: one entry per authenticated route this spec documents, in "<METHOD> <path>" form, not a representative subset. GET /api/v1 is the unauthenticated entrypoint an agent hits first, so it hands back the whole authenticated surface rather than a sample the caller would have to guess around. The example on GET /api/v1 is abridged for readability -- the live response returns all of them. Kept in lockstep with this spec by review: it is a hand-maintained const in backend/src/api_v1/discovery.rs and no automated check compares the two, so treat this spec as authoritative if they ever disagree. */
+    authenticated_routes: string[];
+};
+export type ApiError = {
+    object: "error";
+    error: {
+        code: "bad_request" | "invalid_api_key" | "subscription_required" | "forbidden" | "not_found" | "account_locked" | "rate_limited" | "rate_limit_unavailable" | "internal_error";
+        message: string;
+        doc_url?: string | null;
+        param?: string | null;
+        /** The recommended next request instant (RFC3339), always in the future. Present on every retryable error: `pick_not_released`, `rate_limited`, `rate_limit_unavailable`, and `read_model_warming`. Omitted otherwise. The absolute twin of `Retry-After`; prefer the header for the sleep duration. For `pick_not_released`, the earliest of the next scheduled release, the next automatic selector attempt, the operating-window start, or about 60 seconds. See that response. */
+        retry_at?: string | null;
+        /** ADDITIVE (#7209). The specific, actionable cause behind `code`, when there is one more specific than the code itself. `code` keeps its published values, so existing clients are unaffected; new clients branch on `reason`. Omitted when the code already says everything we know. pick_not_released: no Pick of the Day is published for the current product day; schedule one request against retry_at instead of polling. unknown_endpoint: the PATH is not a route on this API -- read GET /api/v1, do not retry. trader_not_tracked: the wallet is real and the URL is right, but the trader is outside the HOT/WARM sync tiers -- stop asking for this wallet. cursor_expired: pagination went stale mid-walk -- re-request the first page and continue. read_model_warming: the requested endpoint cannot serve its read model yet; exact causes are endpoint-specific and can include a cold or contended refresh or a dependency that prevented refresh. database_unavailable: the API's database or its connection pool is temporarily unreachable (a connection-class failure, not a query fault); code stays rate_limit_unavailable, nothing is rate-limited, retry after Retry-After / retry_at. idempotency_in_progress: retain the exact Idempotency-Key and request body, then retry shortly. webhook_delivery_in_progress: retry the URL or signing-secret configuration change after the destination's active request completes. request_accounting_unavailable: accounting capacity is unavailable before the handler executes; retry after Retry-After / retry_at. sandbox_api_key: the credential is a sandbox key (oxi_sk_test_) from POST /api/v1/agents/register, which only the sandbox server accepts -- call the sandbox base URL with it, or get a live key or OAuth access token; do not retry it here. api_key_in_query: the key was sent as a ?token= query parameter, which no route reads because URLs land in logs and history; the key itself was not checked -- resend it as Authorization: Bearer. subscription_inactive: the key is valid but the account's Pro subscription has lapsed (402 subscription_required); permanent until a person reactivates at https://0xinsider.com/billing, which the message names -- stop retrying on a schedule and surface the link. The key owner is emailed once per lapse. */
+        reason?: "cursor_expired" | "unknown_endpoint" | "pick_not_released" | "trader_not_tracked" | "read_model_warming" | "database_unavailable" | "request_accounting_unavailable" | "idempotency_in_progress" | "webhook_delivery_in_progress" | "sandbox_api_key" | "api_key_in_query" | "subscription_inactive";
+    };
+    meta: ResponseMeta;
+};
+export type ApiErrorBody = {
+    code: "bad_request" | "invalid_api_key" | "subscription_required" | "forbidden" | "not_found" | "account_locked" | "rate_limited" | "rate_limit_unavailable" | "internal_error";
+    message: string;
+    doc_url?: string | null;
+    param?: string | null;
+    /** The recommended next retry instant (RFC3339). Present on every retryable error (reason=pick_not_released, code=rate_limited, code=rate_limit_unavailable, reason=read_model_warming) and omitted otherwise. Always in the future. For pick_not_released: before the 11:00 UTC operating-window start, before a selected pick's stored release, or after a skipped day, it names the automatic system's next boundary. While no candidate exists in the live window it normally names the persisted next automatic selector attempt. Every value is advisory under supported operator actions: manual publication, release-time override, or admin generation can make a pick available first. When the automatic schedule is absent/due or a pick is overdue it degrades to ~60s. Schedule one request and do not poll. Prefer Retry-After for the duration because it is immune to client clock skew. */
+    retry_at?: string | null;
+    /** ADDITIVE (#7209). The specific, actionable cause behind `code`, when there is one more specific than the code itself. `code` keeps its published values, so existing clients are unaffected; new clients branch on `reason`. Omitted when the code already says everything we know. pick_not_released: no Pick of the Day is published for the current product day; schedule one request against retry_at instead of polling. unknown_endpoint: the PATH is not a route on this API -- read GET /api/v1, do not retry. trader_not_tracked: the wallet is real and the URL is right, but the trader is outside the HOT/WARM sync tiers -- stop asking for this wallet. cursor_expired: pagination went stale mid-walk -- re-request the first page and continue. read_model_warming: the requested endpoint cannot serve its read model yet; exact causes are endpoint-specific and can include a cold or contended refresh or a dependency that prevented refresh. database_unavailable: the API's database or its connection pool is temporarily unreachable (a connection-class failure, not a query fault); code stays rate_limit_unavailable, nothing is rate-limited, retry after Retry-After / retry_at. idempotency_in_progress: retain the exact Idempotency-Key and request body, then retry shortly. webhook_delivery_in_progress: retry the URL or signing-secret configuration change after the destination's active request completes. request_accounting_unavailable: accounting capacity is unavailable before the handler executes; retry after Retry-After / retry_at. sandbox_api_key: the credential is a sandbox key (oxi_sk_test_) from POST /api/v1/agents/register, which only the sandbox server accepts -- call the sandbox base URL with it, or get a live key or OAuth access token; do not retry it here. api_key_in_query: the key was sent as a ?token= query parameter, which no route reads because URLs land in logs and history; the key itself was not checked -- resend it as Authorization: Bearer. subscription_inactive: the key is valid but the account's Pro subscription has lapsed (402 subscription_required); permanent until a person reactivates at https://0xinsider.com/billing, which the message names -- stop retrying on a schedule and surface the link. The key owner is emailed once per lapse. */
+    reason?: "cursor_expired" | "unknown_endpoint" | "pick_not_released" | "trader_not_tracked" | "read_model_warming" | "database_unavailable" | "request_accounting_unavailable" | "idempotency_in_progress" | "webhook_delivery_in_progress" | "sandbox_api_key" | "api_key_in_query" | "subscription_inactive";
+};
+export type BatchMarketIntelItem = {
+    /** Zero-based request index. Duplicate inputs keep separate result rows. */
+    index: number;
+    input: string;
+    status: "ok" | "error";
+    data?: MarketIntel;
+    error?: ApiErrorBody;
+};
+export type BatchRateLimitMeta = {
+    basis: "batch_items_per_minute";
+    limit: number;
+    remaining: number;
+    /** Unix timestamp when the batch item window resets. */
+    reset: number;
+};
+export type BatchResponseMeta = {
+    request_id: string;
+    cached: boolean;
+    total_items: number;
+    successful_items: number;
+    failed_items: number;
+    /** Number of batch item units reserved before execution. */
+    request_cost: number;
+    rate_limit: BatchRateLimitMeta;
+};
+export type BatchTraderItem = {
+    /** Zero-based request index. Duplicate inputs keep separate result rows. */
+    index: number;
+    input: string;
+    status: "ok" | "error";
+    data?: Trader;
+    error?: ApiErrorBody;
+};
+/** One bucketed OHLC price candle. Prices are in provider [0, 1] units, truncated to 4 decimals at the rendering edge. */
+export type Candle = {
+    /** Bucket-start unix epoch (seconds): UTC midnight for 1d, the ISO-week Monday's UTC midnight for 1w. */
+    t: number;
+    /** Open price in provider [0, 1] units (first observed point in the bucket). */
+    o: number;
+    /** High price in provider [0, 1] units (max observed in the bucket). */
+    h: number;
+    /** Low price in provider [0, 1] units (min observed in the bucket). */
+    l: number;
+    /** Close price in provider [0, 1] units (last observed point in the bucket). */
+    c: number;
+};
+export type ContentSearchResult = {
+    /** Backend-owned stable editorial content identifier. */
+    content_id: string;
+    /** Editorial content kind. */
+    kind: "learn" | "glossary" | "comparison" | "research" | "strategy";
+    /** Backend-owned content slug. */
+    slug: string;
+    /** Editorial title. */
+    title: string;
+    /** Search-result excerpt. */
+    excerpt: string;
+    /** Canonical first-party content URL. */
+    url: string;
+};
+export type CounterpartyAnalysis = {
+    status: "available" | "partial" | "unavailable";
+    unavailable_reason?: string | null;
+    /** Deterministic immutable membership snapshot for this detail response. */
+    snapshot_id?: string | null;
+    /** Stable digest binding page cursors to one snapshot and execution set. */
+    analysis_id?: string | null;
+    execution_count: number;
+    available_execution_count: number;
+    unavailable_execution_count: number;
+    executions: CounterpartyExecution[];
+    /** Stable cursor after the last execution included in the bounded inline page. */
+    executions_next_cursor?: string | null;
+};
+export type CounterpartyExecution = {
+    execution_id: string;
+    exchange_family: "ctf_v2" | "neg_risk_ctf_v2";
+    transaction_hash: string;
+    orders_matched_log_index: number;
+    taker: CounterpartyParticipant;
+    makers: CounterpartyParticipant[];
+    /** Stable cursor after the last maker included in the bounded inline page. */
+    makers_next_cursor?: string | null;
+};
+export type CounterpartyMakerPage = {
+    analysis_id: string;
+    snapshot_id: string;
+    execution_id: string;
+    items: CounterpartyParticipant[];
+    /** Cursor bound to the analysis, execution, last full-denominator share total, and wallet. */
+    next_cursor?: string | null;
+};
+export type CounterpartyMatchBreakdown = {
+    match_type: "COMPLEMENTARY" | "MINT" | "MERGE";
+    maker_fill_count: number;
+    /** Exact decimal shares. */
+    filled_shares: string;
+};
+export type CounterpartyParticipant = {
+    counterparty_key: string;
+    /** Lowercase Polygon wallet from the exact OrderFilled log. */
+    execution_wallet: string;
+    identity_status: "resolved" | "infrastructure" | "unavailable";
+    resolved_user_id?: string | null;
+    wallet_family?: string | null;
+    resolution_block?: number | null;
+    resolution_source?: string | null;
+    display_name?: string | null;
+    grade?: string | null;
+    /** 0xinsider profile path segment for this participant, present only when the execution wallet has a tracked trader: `@<username>` when that username resolves to the trader alone, otherwise the trader's lowercase wallet. Percent-encode the part after `@` and append to `https://0xinsider.com/profile/`. */
+    profile_segment?: string | null;
+    maker_fill_count: number;
+    /** Exact decimal shares. */
+    filled_shares: string;
+    /** Exact decimal USDC amount. */
+    filled_usdc: string;
+    /** Participant share of the exact execution, from 0 through 100. */
+    share_pct: string;
+    match_breakdown: CounterpartyMatchBreakdown[];
+};
+export type CreateWebhookRequest = {
+    name: string;
+    /** Public HTTPS callback URL on the default port 443. Local, private, and internal targets are rejected, as is any explicit port other than 443 and any URL carrying credentials. Each user's URLs are unique after normalizing HTTPS scheme/host case, trailing DNS dots and port 443; path/query case is preserved. Pending verification and PATCH-disabled endpoints still reserve their stored URL. The destination must answer the signed webhook.verification challenge with a 2xx before POST /api/v1/webhooks/{id}/verify can activate the endpoint. */
+    url: string;
+    event_types: WebhookEventType[];
+};
+export type EventReplayEvent = {
+    /** Opaque event ID; currently identical to cursor for the whale_alerts.id sequence. */
+    id: string;
+    type: "whale_trades_inserted";
+    /** Cursor positioned at this event. */
+    cursor: string;
+    /** Global whale_alerts.id sequence. */
+    sequence: number;
+    published_at: string;
+    payload: Record<string, unknown>;
+    source: EventReplaySource;
+    freshness: EventReplayFreshness;
+};
+export type EventReplayFreshness = {
+    status: "observed";
+    observed_at: string;
+};
+export type EventReplayMeta = {
+    /** Unique request ID (req_ prefix). */
+    request_id: string;
+    cached: boolean;
+    cache_age_s?: number | null;
+    /** Advisory request weight (relative compute cost). 1 for simple reads; higher for heavier endpoints. Not a credit/price. */
+    cost: number;
+    replay: {
+        from_cursor: string;
+        to_cursor: string;
+        from_sequence: number;
+        to_sequence: number;
+        ordering: "whale_alerts_id_asc";
+    };
+    retention: {
+        status: "durable_database";
+        retained_events: number;
+        cursor_expired: false;
+    };
+    completeness: {
+        status: "complete" | "caught_up";
+        reason: string;
+    };
+};
+export type EventReplaySource = {
+    kind: "local_durable_replay";
+    producer_family: "whale_trades";
+    owner: "whale_alerts";
+    provider_fetch_at_request_time: false;
+};
+export type ExploreEntry = ExploreGroup | ExploreStandalone;
+export type ExploreFacets = {
+    categories: ExploreFacetValue[];
+    platforms: ExploreFacetValue[];
+};
+export type ExploreFacetValue = {
+    value: string;
+    label: string;
+    count: number;
+};
+export type ExploreGroup = {
+    type: "group";
+    event_slug: string;
+    parent_title: string;
+    image?: string | null;
+    platform?: string | null;
+    category?: string | null;
+    /** Markets in the event cluster, ranked by volume with condition_id as the tie-breaker. The selected representative is retained within the 12-market cap. */
+    markets: ExploreMarket[];
+    rep_volume?: number | null;
+    rep_whales?: number | null;
+};
+export type ExploreMarket = {
+    id: string;
+    condition_id: string;
+    /** Non-empty market title. */
+    title: string;
+    /** Provider-native market slug. */
+    slug?: string | null;
+    /** First-party market page slug used for internal links. */
+    url_slug?: string | null;
+    image?: string | null;
+    icon?: string | null;
+    category?: string | null;
+    platform?: string | null;
+    status: "active" | "closed";
+    volume?: number | null;
+    liquidity?: number | null;
+    whale_trade_count?: number | null;
+    whale_distinct_wallets?: number | null;
+    whale_total_usd?: number | null;
+    whale_last_trade_at?: string | null;
+    end_date?: string | null;
+    created_at?: string | null;
+    outcome_yes?: string | null;
+    /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the YES outcome; null when unavailable (e.g. unsynced markets). */
+    token_id_yes?: string | null;
+    outcome_no?: string | null;
+    /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the NO outcome; null when unavailable (e.g. unsynced markets). */
+    token_id_no?: string | null;
+    event_slug?: string | null;
+    smart_score?: number | null;
+    smart_count?: number | null;
+    smart_label?: string | null;
+    /** Display label for the YES/outcome_index=0 side, enriched from provider outcome metadata when available. */
+    outcome_yes_label?: string | null;
+    /** Display label for the NO/outcome_index=1 side, enriched from provider outcome metadata when available. */
+    outcome_no_label?: string | null;
+    /** Provider-owned YES/outcome_index=0 identifier when available for trade-ticket wiring. */
+    outcome_yes_provider_id?: number | null;
+    /** Provider-owned NO/outcome_index=1 identifier when available for trade-ticket wiring. */
+    outcome_no_provider_id?: number | null;
+    open_interest?: number | null;
+    oi_change_pct?: number | null;
+    price_points?: number[][] | null;
+    no_price_points?: number[][] | null;
+    last_price?: number | null;
+    no_last_price?: number | null;
+    change_pct_24h?: number | null;
+    no_change_pct_24h?: number | null;
+    /** Backend-owned deterministic market discovery score used by the hot sort. */
+    discover_score?: number | null;
+    score_components?: {
+        volume_signal?: number | null;
+        whale_signal?: number | null;
+        liquidity_signal?: number | null;
+        recency_signal?: number | null;
+        smart_money_signal?: number | null;
+        price_move_signal?: number | null;
+        missing_price_penalty: number;
+    };
+    freshness?: {
+        enrichment_status: "available" | "unavailable";
+        price_status: "available" | "unavailable";
+    };
+};
+export type ExploreStandalone = {
+    type: "standalone";
+    market: ExploreMarket;
+};
+export type ExportCompleteness = {
+    status: "complete" | "partial" | "empty";
+    reason: string;
+    sync_coverage: number;
+};
+export type ExportCounts = {
+    pnl_days: number;
+    exported_markets: number;
+    estimated_trade_rows: number;
+    estimated_size_mb: number;
+};
+export type ExportSourceRange = {
+    first_pnl_date?: string | null;
+    last_pnl_date?: string | null;
+    latest_trade_at?: string | null;
+    latest_market_activity_at?: string | null;
+};
+export type ExportVolumeReconciliation = {
+    provider_lifetime_volume?: number | null;
+    exported_activity_volume: number;
+    exported_market_cost_basis: number;
+    provider_activity_volume_gap?: number | null;
+    activity_volume_coverage?: number | null;
+};
+export type LargeExportPolicy = {
+    mode: "v1_async_export";
+    current_internal_route: string;
+    /** Programmatic API-key-gated export routes (submit/status/download) and supported formats (json, ndjson, csv). */
+    v1_async: {
+        /** POST route template to submit an export job. */
+        submit_route?: string;
+        /** GET route template to poll job status. */
+        status_route?: string;
+        /** GET route template that 302-redirects to the file. */
+        download_route?: string;
+        /** Supported ?format= values. */
+        formats?: ("json" | "ndjson" | "csv")[];
+        /** Possible job status values. */
+        status_values?: ("queued" | "running" | "ready" | "failed")[];
+        /** How long a finished export is retained before expiry. */
+        retention?: string;
+    };
+    direct_streaming: Record<string, unknown>;
+    async_job: Record<string, unknown>;
+    rate_limit: Record<string, unknown>;
+};
+export type LargePosition = {
+    /** Composite prefixed ID `pos_<wallet>:<condition_id>:<outcome_index>`. */
+    id: string;
+    /** Provider discriminator. Always polymarket. */
+    platform: "polymarket";
+    /** Aggregate provider currentValue for this position leg in USD. */
+    total_size_usd?: number | null;
+    /** Provider per-position unrealized P&L (trader_markets.unrealized_pnl_num, from Polymarket cashPnl). */
+    position_unrealized_pnl?: number | null;
+    /** Live share count for this position. */
+    share_count: number;
+    /** Volume-weighted entry price. */
+    avg_entry_price?: number | null;
+    /** Latest provider mark price for the position's token. */
+    current_price?: number | null;
+    /** Backend-resolved outcome label (provider outcome, else Yes/No from the binary index). */
+    outcome_label?: string | null;
+    /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for this outcome; null when unavailable (e.g. unsynced markets). */
+    token_id?: string | null;
+    /** Legs collapsed into this representative row for one (wallet, event, outcome side) group. 1 means standalone. */
+    event_leg_count: number;
+    /** Aggregate provider currentValue across collapsed sibling legs; equals total_size_usd when event_leg_count = 1. */
+    event_total_value_usd?: number | null;
+    first_seen_at: string;
+    last_updated_at: string;
+    trader: {
+        /** Prefixed ID (`trd_...`). */
+        id: string;
+        address: string;
+        username?: string | null;
+        grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        win_rate?: number | null;
+        /** Trader lifetime realized P&L across all markets. */
+        pnl?: number | null;
+        markets_traded?: number | null;
+    };
+    market: {
+        /** Prefixed ID (`mkt_...`). */
+        id: string;
+        condition_id: string;
+        title?: string | null;
+        slug?: string | null;
+        event_slug?: string | null;
+        category?: string | null;
+    };
+};
+export type LeaderboardEntry = {
+    id: string;
+    address: string;
+    username?: string | null;
+    grade?: string | null;
+    /** Hot-streak tier (trailing-7d cross-sectional percentile); a separate axis from the all-time grade. Null when no recent activity. */
+    streak_tier?: "hot" | "rising" | "neutral" | "cooling" | "cold";
+    score?: number | null;
+    /** All-time P&L in USD (total_pnl), including unrealized open positions. Kept for back-compat; prefer realized_pnl for the banked figure. */
+    pnl?: number | null;
+    /** All-time banked realized P&L in USD (total_pnl - open_pnl), excluding unrealized open positions. Matches the realized-P&L-dominant grade/board. */
+    realized_pnl?: number | null;
+    volume?: number | null;
+    markets_traded?: number | null;
+    win_rate?: number | null;
+    strategy_type?: string | null;
+    platform: string;
+    last_active?: string | null;
+};
+/** Provider-first bucketed OHLC price candles for a market's outcome tokens, derived from the stored token_price_snapshots series (covers open and resolved markets). */
+export type MarketCandles = {
+    /** Market condition id the candles were read for. */
+    condition_id: string;
+    /** Bucketing granularity that produced these candles. */
+    resolution: "1d" | "1w";
+    /** One entry per present provider token (YES first, then NO); empty when no tokens have been fetched yet. */
+    outcomes: OutcomeCandles[];
+};
+export type MarketIntel = {
+    market: {
+        id: string;
+        condition_id: string;
+        title: string;
+        slug?: string | null;
+        category?: string | null;
+        platform?: string | null;
+    };
+    /** Outcome-aware flow from all tracked whale trades in the window, without a grade filter. BUY YES and SELL NO add net exposure; BUY NO and SELL YES subtract it. Gross buy/sell volumes count both outcomes. Top positions are separately graded. Direction uses unrounded net: negative is NO, otherwise YES; the zero tie-break is not conviction. Canonical; smart_money is a deprecated byte-identical alias. */
+    sharp_money: {
+        net_flow_usd: number;
+        direction: "YES" | "NO";
+        /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the net-flow direction outcome; null when unavailable (e.g. unsynced markets). */
+        token_id?: string | null;
+        whale_trade_count: number;
+        buy_volume_usd: number;
+        sell_volume_usd: number;
+        top_positions: ({
+            id: string;
+            address: string;
+            username?: string | null;
+            grade?: string | null;
+            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;
+            size_usd: number;
+        })[];
+    };
+    /** Deprecated alias of sharp_money; byte-identical and retained for backward compatibility. */
+    smart_money: {
+        net_flow_usd: number;
+        direction: "YES" | "NO";
+        /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the net-flow direction outcome; null when unavailable (e.g. unsynced markets). */
+        token_id?: string | null;
+        whale_trade_count: number;
+        buy_volume_usd: number;
+        sell_volume_usd: number;
+        top_positions: ({
+            id: string;
+            address: string;
+            username?: string | null;
+            grade?: string | null;
+            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;
+            size_usd: number;
+        })[];
+    };
+    timeframe: string;
+};
+export type MarketSearchResult = {
+    id: string;
+    condition_id: string;
+    title: string;
+    slug?: string | null;
+    category?: string | null;
+    platform?: string | null;
+    status: "active" | "closed";
+};
+export type MarketSnapshot = {
+    market: {
+        id: string;
+        condition_id: string;
+        provider: string;
+        title?: string | null;
+        slug?: string | null;
+        page_slug?: string | null;
+        event_slug?: string | null;
+        category?: string | null;
+        status: "active" | "closed";
+        description?: string | null;
+        image?: string | null;
+        /** Polymarket series slug from the canonical identity row, null when unavailable. A sports series identifies a league and must not be used as a per-matchup grouping key. */
+        series_slug?: string | null;
+        market_type?: string | null;
+        market_result?: string | null;
+        created_at?: string | null;
+        end_date?: string | null;
+        resolved_at?: string | null;
+    };
+    outcomes: ({
+        side: "yes" | "no";
+        label: string;
+        token_id?: string | null;
+        current_price?: number | null;
+        top_of_book: MarketSnapshotTopOfBook;
+    })[];
+    liquidity: {
+        source: string;
+        volume_usd?: number | null;
+        liquidity_usd?: number | null;
+        volume_24h_usd?: number | null;
+        /** Always null. Polymarket snapshot prices come from outcome top-of-book midpoints. */
+        last_price?: number | null;
+    };
+    sports: {
+        status: "fresh" | "stale" | "not_live" | "unavailable";
+        source: string;
+        live_match_key?: string | null;
+        live_league_key?: string | null;
+        /** Live-score period and elapsed may be omitted when unavailable (older responses use null). A score entry may omit full_name when it equals team; fall back to team. Distinct aliases and score admission markers are preserved. */
+        live_score?: Record<string, unknown> | null;
+        reason?: string | null;
+    };
+    freshness: {
+        market_data: MarketSnapshotFreshness;
+        top_of_book: MarketSnapshotFreshness;
+        /** Freshness requires the dedicated two-second post-publication marker to match the retained vintage and non-invalidated data timestamp; timestamp presence alone is insufficient. as_of records compute start, so stale_after_s is omitted rather than implying as_of plus two seconds. Missing membership is not_live only in a fresh source; stale membership remains stale and unreadable source data is unavailable. Repeated lookups reuse the shared payload and typed index for an unchanged generation. */
+        live_sports: MarketSnapshotFreshness;
+    };
+    /** Price and spread trust metadata. Present only when expand=trust or expand[]=trust is requested. */
+    trust?: MarketSnapshotTrust;
+};
+export type MarketSnapshotFreshness = {
+    status: "fresh" | "stale" | "available" | "not_live" | "unavailable";
+    source: string;
+    as_of?: string | null;
+    /** Age-relative freshness bound when known. Omitted for live_sports: its as_of records compute start, while its two-second freshness marker starts at publication. */
+    stale_after_s?: number | null;
+    reason?: string | null;
+};
+export type MarketSnapshotTopOfBook = {
+    status: "available" | "unavailable";
+    source: string;
+    best_bid?: number | null;
+    best_ask?: number | null;
+    spread_bps?: number | null;
+    bid_depth_usdc?: number | null;
+    ask_depth_usdc?: number | null;
+    reason?: string | null;
+};
+/** Price and spread trust metadata returned only when GET /api/v1/market/{condition_id}/snapshot includes expand=trust. */
+export type MarketSnapshotTrust = {
+    current_price: TrustMetadata;
+    spread_bps: TrustMetadata;
+};
+export type McpJsonRpcError = {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    error: {
+        code: number;
+        message: string;
+        /** Optional JSON-serializable error data. */
+        data?: Record<string, unknown> | unknown[] | string | number | boolean | null;
+    };
+};
+/** One outcome token's bucketed candle series. */
+export type OutcomeCandles = {
+    /** Provider CLOB token id the candles were read for. */
+    token_id: string;
+    /** Canonical side label. */
+    outcome: "YES" | "NO";
+    /** OHLC candles for this outcome token, ascending by bucket start. */
+    candles: Candle[];
+};
+export type PickHolder = {
+    address: string;
+    name?: string | null;
+    /** All-time trader grade (S, A, B, C, D, F). */
+    grade?: string | null;
+    /** 0xinsider profile path segment this wallet links to: `@<username>` when that username resolves to this wallet alone, otherwise the lowercase wallet. Percent-encode the part after `@` and append to `https://0xinsider.com/profile/`. Stamped at serve time; absent on a body cached before the field shipped. */
+    profile_segment?: string | null;
+    shares: number;
+    /** This wallet's win rate in the pick's canonical category bucket (the pick's `category` field, e.g. Basketball -- label the rate with it, never with the narrower `display_category` league): the share of the wallet's resolved markets in that category whose realized P&L closed positive, as a 0..1 fraction. Present only with `category_win_rate_status` = `measured`, on `display_holders` entries, and only when the wallet clears the resolved-market floor; recomputed at serve time from the current category read model, not frozen with the pick. Absent on `holders` entries, legacy rows, and payloads predating the field. */
+    category_win_rate?: number | null;
+    /** Why `category_win_rate` is present or absent on a `display_holders` entry: `measured` (rate present), `not_enough_data` (the wallet is below the resolved-market floor of 5 in the category), or `unavailable` (the annotation read failed; retry later). Absent entirely on `holders` entries, legacy rows, and payloads predating the field -- absence means the roster was never annotated, not a small sample. */
+    category_win_rate_status?: "measured" | "not_enough_data" | "unavailable";
+};
+export type PickOfTheDay = {
+    /** Always 'full' for an authenticated Pro key. */
+    state: "full";
+    /** The pick's local publication date (YYYY-MM-DD). */
+    pick_date: string;
+    /** Stable 1-based slot within the product day's ranked picks. */
+    pick_rank?: number;
+    /** The complete ranked picks for this product day, ordered by pick_rank. Thin days contain fewer items; the selector never fabricates rows. */
+    picks?: PickOfTheDay[];
+    /** Number of items in `picks`: the proof-readable picks. Picks held in `proof_pending_picks` are not counted. */
+    pick_count?: number;
+    /** Same-day picks selected but not yet released, ordered by pick_rank. Additive and optional: present only while at least one unreleased slot exists. Each slot exposes only its rank and schedule -- no market identity before release. Schedule the next read from the earliest release_at instead of polling. */
+    scheduled_picks?: ScheduledPickSlot[];
+    /** Human-readable matchup (e.g. "Portugal vs. Uzbekistan"). */
+    matchup: string;
+    /** Frozen canonical calibration/report bucket (e.g. "Basketball", "MMA", or "Soccer"). Existing semantics are unchanged; presentation consumers should prefer display_category when present. */
+    category: string;
+    /** Frozen public presentation category. For supported Polymarket sports this is the exact verified provider event identity: an official league (e.g. "WNBA" or "UFC"), the esports title (e.g. "CS2", "LoL", "Dota 2" or "Valorant"), or a soccer competition whose official mark we vendor (e.g. "LaLiga", "Premier League", "Serie A" or "UEFA Champions League"). Only identities with a vendored official mark are split out; every other competition keeps its canonical bucket, so "Soccer" remains a live value; otherwise it equals category. An esports pick keeps the pooled "Esports" bucket in category, so a per-title label never implies a per-title measured cohort. Additive and optional for mixed-version client compatibility. */
+    display_category?: string;
+    /** Provider platform (e.g. "polymarket"). */
+    platform: string;
+    /** The pick's stored release instant. Normally the current provider kickoff minus one hour; an operator may override it. The actual publish instant can trail it because of worker or claim delay. */
+    release_at: string;
+    /** True only before the pick's stored release instant (a pre-release embargo flag); effectively always false on a served, already-published pick. To detect that the backed game has kicked off, use `game_started`. */
+    is_locked: boolean;
+    /** True once the backed game's kickoff has passed (kickoff <= now). When true the snapshotted pre-game price is no longer actionable. Absent for a legacy pick with no stored kickoff (treat as not-started). */
+    game_started?: boolean;
+    /** Settlement outcome of the backed side; 'pending' until the market resolves. */
+    outcome: "pending" | "win" | "loss" | "void";
+    /** Pre-formatted SETTLEMENT STATUS for display: "Win" / "Loss" / "Void" / "Pending" -- the outcome enum above as a label. Convenience only; outcome is the source value. NOTE: this is the win/loss STATUS, not the backed side. The backed side is pick_outcome_label ("Belgium (-2.5)") -- a different field answering a different question. */
+    outcome_display?: string;
+    /** The backed side phrased as a bet: a team for a moneyline (e.g. "Portugal"), the handicap line for a spread (e.g. "Belgium (-2.5)"), or "{team} to advance" for a knockout advancement market (e.g. "Spain to advance"). */
+    pick_outcome_label: string;
+    /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the backed outcome; null when unavailable (e.g. unsynced markets). */
+    token_id?: string | null;
+    /** The backed side phrased as a bet (e.g. "Portugal to win"). */
+    position: string;
+    /** One-line summary of which side sharp money is backing. Required on every item in `picks`: a current-day published pick whose required holder proof is not safely readable is listed in `proof_pending_picks` instead of being served with a partial success shape or a synthetic zero, and the route returns 503 read_model_warming only when no published pick has readable proof. */
+    side_summary: string;
+    /** Public V1 compatibility count of S/A smart-money wallets on the backed side. The first-party/internal current policy counts S/A/B; historical rows retain their frozen policy's count. Required on every item in `picks`: a current-day published pick whose required holder proof is not safely readable is listed in `proof_pending_picks` instead of being served with a partial success shape or a synthetic zero, and the route returns 503 read_model_warming only when no published pick has readable proof. */
+    smart_wallet_count: number;
+    /** Best public V1-compatible S/A smart-money grade on the backed side. The first-party/internal current policy can select B, but a current B-only grade is omitted by the stable V1 adapter. Historical rows retain their frozen policy's grade. A current-day published pick with pending legacy proof, unknown-future proof, or structurally invalid current-policy proof returns 503 before this success schema is served. Resolved legacy proof remains readable on both current-day and archive/history responses. */
+    top_grade?: string | null;
+    /** Deprecated (#7170): no longer populated for picks selected on/after the calibration-edge change; omitted (absent) for new picks (the field uses skip_serializing_if, so a null value is dropped from the JSON rather than serialized as null). Permanently frozen-legacy -- retained for historical picks, with no removal or replacement planned, so no v2 is implied. Historical picks may still carry a value. Legacy meaning: category win-rate edge as a fraction (the backed-side cohort's win rate in this category minus the non-market-maker category baseline, e.g. 0.09 = +9 points), paired with category_edge_sample. */
+    category_edge_pct?: number | null;
+    /** Deprecated (#7170): no longer populated for picks selected on/after the calibration-edge change; omitted (absent) for new picks (the field uses skip_serializing_if, so a null value is dropped from the JSON rather than serialized as null). Permanently frozen-legacy -- retained for historical picks, with no removal or replacement planned, so no v2 is implied. Historical picks may still carry a value. Legacy meaning: pooled count of resolved markets behind category_edge_pct (the headline's n). */
+    category_edge_sample?: number | null;
+    /** Recency-weighted graded-flow magnitude in USD; omitted when <= 0. */
+    smart_usd?: number | null;
+    /** Pre-game snapshot probability (0..1) for the backed side. */
+    backed_price?: number | null;
+    /** Full-only disclosure when backed_price was recovered from provider history within 30 seconds before publication. Render beside the price. Absent for ordinary publication captures and teasers; this is a historical reference, not an executed fill. */
+    entry_price_note?: string;
+    /** Pre-formatted backed_price as cents-on-the-dollar odds, to ONE decimal: "62.0c" / "99.9c". Never rounded to a whole cent -- a 99.9c favorite is not a 100c certainty. Convenience only; backed_price is the source value. Omitted when backed_price is. */
+    odds_display?: string | null;
+    /** Gross return on a $100 stake at the snapshotted price (100 / backed_price). */
+    return_per_100?: number | null;
+    /** Pre-formatted return_per_100 as USD with cents and thousands separators: "$161.29" / "$1,250.00". The GROSS return (the $100 stake included), so it carries no sign. Convenience only; return_per_100 is the source value. Omitted when return_per_100 is. */
+    payout_display?: string | null;
+    /** Pre-formatted PROFIT on the $100 stake -- return_per_100 minus the 100 stake, i.e. the payout net of what you put in -- as a signed USD string: "+$61.29". Distinct from payout_display, which is gross. Omitted when return_per_100 is. */
+    profit_display?: string | null;
+    /** Backend-owned CLV capture disposition. "pending" means no capture decision exists yet; terminal provider or quality statuses remain distinguishable. The raw close price and timestamp are never serialized. */
+    clv_status: string;
+    /** Backend-owned CLV evidence basis. `frozen_displayed_entry` uses the persisted displayed entry. `historical_provider_entry` uses a known-CLOB point at or before publication. `historical_provider_price_match` requires the latest point in the prior hour to match. `historical_provider_nearby_price_match` requires a matching point within five minutes before publication. Source-null bases preserve unknown original provenance. */
+    clv_basis?: string;
+    /** Closing-line value toward the backed side, computed as (close / entry - 1) * 100. The basis-specific provider p entry must match the stored display; historical_provider_price_match also requires source provenance to remain null and its latest entry to be within the one-hour window at or before publication. Every basis requires a later quality-checked p close from the same series in the bounded post-entry, pre-kickoff window. Omitted when not measured. */
+    clv_pct?: number;
+    /** Backend-formatted signed CLV percentage, present exactly when clv_pct is present. */
+    clv_display?: string;
+    /** Backend-owned CLV formula text with the entry probability, close probability, and rounded result. Provider timestamps remain private. */
+    clv_explanation?: string;
+    /** Net return for the pick in the existing $100 stake units. Omitted when the outcome is not valued. */
+    unit_score?: number;
+    /** Backend-formatted signed unit score, present exactly when unit_score is present. */
+    unit_score_display?: string;
+    /** First-party/internal backed-side sharp-money dollar consensus as a fraction 0..1: the share of current-policy sharp dollars on the backed side. Omitted on current public V1 rows when the B-inclusive value has no reconstructible S/A equivalent. A conviction signal, NOT a probability or expected-value claim. Frozen at generation. */
+    sharp_pct?: number | null;
+    /** Market-implied probability of the backed side as a fraction 0..1 (equals backed_price), re-exposed alongside sharp_pct for the WHY breakdown. */
+    market_pct?: number | null;
+    /** First-party/internal consensus edge = sharp_pct - market_pct, the conviction-vs-price gap (how much more of the current-policy sharp money sits on this side than the price implies). Omitted on current public V1 rows when the B-inclusive value has no reconstructible S/A equivalent. This is NOT an expected-value or guaranteed edge. Null when either input is null. */
+    consensus_edge_pct?: number | null;
+    /** First-party/internal team-directional commitment read at selection time: the fraction (0..1) of the backed side's current-policy graded sharp-money DOLLARS held by wallets read one-way rather than hedged: no opposite leg on this market worth at least 10% of the backed leg (Polymarket's own currentValue pair), and no opposing team across the game's markets where the wallet's synced legs are fresh. Current public V1 rows omit this B-inclusive read because its historical S/A equivalent is not reconstructed. A high value means the graded pile is really committed to this side; a low one means much of it is hedged or unreadable. Omitted when the read was not computed (a pick selected before the field existed, an ungroupable game, an empty graded pile, or a pile where no holder carried usable evidence) -- which is NOT the same as 0.0, a computed reading that classified holders and found none one-way. */
+    directional_confidence?: number | null;
+    /** Graded backed-side holders read as one-way-committed on this game. */
+    one_way_holder_count?: number | null;
+    /** Graded backed-side holders read as HEDGED across the game's markets. */
+    hedged_holder_count?: number | null;
+    /** The one-way holders' share of the backed-side graded dollars (the confidence's numerator). */
+    one_way_graded_usd?: number | null;
+    /** Backed-side graded dollars the confidence is measured against (its denominator). */
+    total_graded_usd?: number | null;
+    /** The qualifying category expert whose sport-specific record and real position earned this pick its top selection tier. The first-party/internal current policy admits S/A/B; public V1 exposes a compatible S/A expert and omits a current-policy B-grade expert: a candidate backed by one outranks every candidate without one. Present only on the full payload. Omitted when no wallet qualified on the backed side, on picks generated before the field existed, and on the first-party web teaser, which withholds all backed-side evidence. Frozen at SELECTION time — the wallet's position can move before the pick renders. */
+    qualifying_expert?: {
+        /** Wallet address of the qualifying expert. */
+        address: string;
+        /** Provider display name, or null for an unnamed wallet. */
+        name?: string | null;
+        /** 0xinsider grade letter. The first-party/internal current Pick of the Day policy counts S, A, and B; public V1 exposes only the compatible S/A expert. */
+        grade?: string | null;
+        /** The canonical sport bucket the win rate was measured over (for example Basketball). Can be BROADER than the pick's display_category, which names an exact league such as NBA — label the rate with this field, never with display_category. */
+        canonical_category: string;
+        /** Share of this wallet's resolved markets in canonical_category whose realized P&L came out positive, as a 0..1 fraction. Above 0.60 by construction for a source=v1 expert; null for an expert who qualified on the category-skill v2 definition only. Deliberately NOT phrased as "closed profitable": the metric counts realized P&L above zero, so a resolved winner the wallet never redeemed sits at zero and counts against it. */
+        win_rate?: number | null;
+        /** Resolved markets in canonical_category behind win_rate. At least 10 by construction for a source=v1 expert; null with win_rate. */
+        n_resolved?: number | null;
+        /** Current expert policy 10 does not require a category-skill v2 specialist in any sport; in every sport a specialist raises the candidate's rank tier rather than gating it. Standard specialists need a positive edge_lower_95 over enough independent events and enough net backing on the backed side; the floors are not published. Fresh healthy records below the shared model's live sample floor can qualify; stale, unknown and degraded records cannot. Historical records preserve which definition qualified the wallet: v1, the profitability rate (win_rate over n_resolved), or v2, the forward-only category-skill calibration edge (edge_lower_95 over independent_event_count). Absent on picks frozen before the v2 definition existed; read absence as v1. A Tennis pick frozen under gate policy v4 or later carries v2 only: a v1 rate stopped qualifying a tennis expert at v4. A Tennis pick frozen under an earlier policy can still carry v1 with a win rate. */
+        source?: "v1" | "v2";
+        /** 95% lower bound of the wallet's mean calibration edge over the market price in canonical_category, in probability units (0.08 is 8 points). Positive by construction for a v2 expert; present on a v1 expert only when the wallet also holds a live v2 row. */
+        edge_lower_95?: number | null;
+        /** Point estimate behind edge_lower_95. */
+        edge_mean?: number | null;
+        /** Independent canonical events behind the edge. At least 10 by construction for a v2 expert. */
+        independent_event_count?: number | null;
+        /** Polymarket's own currentValue for this wallet on the backed outcome, in USD, as of selection. At least 1000 by construction through gate policy v7; the standard floor is 500 from v8. From gate policy v5 the floor is read on the net: position_usd minus opposite_position_usd is at least that floor, and the pick re-verifies that net against the live holder snapshot when it is released. */
+        position_usd: number;
+        /** The same wallet's currentValue on the OTHER outcome of this market, in USD, as of selection. Present from gate policy v5, when the floor moved to net exposure; a wallet long both sides does not qualify. Absent on picks frozen before v5, which never read the leg. 0 is a measured one-way position, not an absence. */
+        opposite_position_usd?: number | null;
+        /** When the skill read model behind the evidence was last rebuilt: trader_category_stats.computed_at for a source=v1 expert, category_skill_v2_current.as_of for a source=v2 expert. */
+        stats_computed_at: string;
+        /** Present from expert policy 6. Current expert policy 10 retains the longshot requirement of live v2 only, with a positive lower bound over a large sample, large net backed value and no meaningful opposite value. Historical policy 6: a specialist required large net backed value, no meaningful opposite value, and either a live v2 positive lower bound over a large sample or a high v1 rate over enough resolved markets. Tennis requires v2. The floors are not published. */
+        lane?: "standard" | "longshot_specialist";
+        /** Answered, spread-gated, index-scoped backed probability frozen only on a specialist exception. */
+        lane_probability?: number;
+        /** Canonical provider probability pair branch; absent on standard experts. */
+        lane_probability_source?: "p";
+    } | null;
+    trust?: PickTrust;
+    /** Public V1 S/A compatibility count on the backed side (equals the adapted smart_wallet_count). The first-party/internal current policy counts S/A/B. Historical rows retain their frozen policy's count. */
+    traders?: number | null;
+    /** Raw backed-side sharp-money USD frozen at generation. This is the Sharp USD value, not the recency-weighted smart_usd which decays. Omitted on current public V1 rows when the B-inclusive value has no reconstructible S/A equivalent. */
+    backed_sharp_usd?: number | null;
+    /** Bounded S/A compatibility projection of the frozen sharp-money holders on the backed side. Current full payloads expose the complete S/A/B roster in display_holders; historical rows can retain their earlier frozen shape. */
+    holders?: PickHolder[] | null;
+    /** Full-only complete provider-confirmed S/A/B holder roster for the current Pick of the Day backing policy. Omitted for teaser, no-pick, and historical rows whose frozen holder proof predates this policy. Each entry may additionally carry `category_win_rate` / `category_win_rate_status`: the wallet's win rate in the pick's canonical `category`, stamped at serve time from the current category read model (the same annotation the sports sharp-money chips carry). The bounded `holders` compatibility projection never carries these fields. */
+    display_holders?: PickHolder[] | null;
+    /** Exact S/A smart-money proof count on the backed side. The current display_holders roster can be longer because it also carries B-grade smart-money holders. */
+    holder_count?: number | null;
+    /** Optional editorial note attached to the pick. */
+    editorial_note?: string | null;
+    /** Required truthful thesis. With at least one profitable-wallet holder: Profitable wallets hold {pick_outcome_label}[, led by a grade-{top_grade} trader]. Without holder backing: 0xInsider's Pick of the Day is {pick_outcome_label}. Wallet counts are not appended. */
+    thesis: string;
+    /** Canonical web market URL. */
+    market_url?: string | null;
+    /** The canonical /event game-page slug (one neutral page per game), null when the game has no neutral event page. */
+    event_slug?: string | null;
+    /** Backend-resolved /event destination slug for this pick's source market; null is an authoritative no-link decision. */
+    event_link_slug?: string | null;
+    /** Provider-first sports context for the pick's market (team logos, league branding, live score). Full-state only; omitted when the pick is not a team-sports market. */
+    sports_context?: PickSportsContext;
+    /** Risk disclaimer shown with every pick. */
+    disclaimer: string;
+    /** Published same-day picks whose holder proof is not readable yet, ordered by pick_rank. Additive and optional: present only while at least one such pick exists. While present, `picks` carries only the proof-readable picks and `pick_count` counts them. Schedule the next read from the earliest retry_at instead of polling. The route returns 503 read_model_warming only when no published pick has readable proof. */
+    proof_pending_picks?: ProofPendingPickSlot[];
+    /** Frozen admission classification, full payload only. The specialist lane exempts two probability rejects and adds no rank bonus. Historical rows remain standard. */
+    selection_lane?: "standard" | "longshot_specialist";
+    /** Optional full-only authorization for newly issued policy-7 picks; omitted for legacy or unissued picks and teasers. It remains historical after expiry. */
+    entry_authorization?: PotdEntryAuthorization;
+};
+export type PickOfTheDayArchive = {
+    /** Every published Pick of the Day, newest first by pick_date and then pick_rank within each product day. */
+    picks: PickOfTheDayArchiveEntry[];
+    /** One entry per product day that has a published pick, 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;
+};
+export type PickOfTheDayArchiveDay = {
+    /** The product day (YYYY-MM-DD). */
+    date: string;
+    /** Published picks on the day: wins + losses + void + pending. */
+    picks: number;
+    /** Picks on the day that resolved as a win, counted by the same pass as hit_rate.wins, so the day entries sum to the headline record. */
+    wins: number;
+    /** Picks on the day that resolved as a loss, counted by the same pass as hit_rate.losses. */
+    losses: number;
+    /** Picks on the day that resolved void (stake refunded). */
+    void: number;
+    /** Picks on the day not yet resolved. A day whose picks are all pending is a real 0-0 day with pending > 0, not a missing record. */
+    pending: number;
+    /** Net units over the day's visible, valued, decided (win/loss) picks: the same population staked_usd runs over. Omitted when the day has not scored -- every pick still pending, every pick void, or a price-gated current row -- which is not the same as a real 0.0 day. */
+    unit_score?: number;
+    /** unit_score pre-formatted as signed units to two decimals (for example +1.24u or -2.00u), by the same formatter the per-pick unit_score_display and hit_rate.unit_score_display use. Present exactly when unit_score is; unit_score is the source value. */
+    unit_score_display?: string;
+    /** win when every decided pick on the day won, loss when every one lost, over at least three decided (win or loss) picks with nothing pending. Omitted for every other day. A void is not a result: it neither lifts a day over the floor nor spoils a sweep. */
+    sweep?: "win" | "loss";
+};
+export type PickOfTheDayArchiveEntry = {
+    /** The pick's local publication date (YYYY-MM-DD). */
+    pick_date: string;
+    /** Stable 1-based slot within the product day's ranked picks. */
+    pick_rank?: number;
+    /** Human-readable matchup (e.g. "Portugal vs. Uzbekistan"). */
+    matchup: string;
+    /** Frozen canonical calibration/report bucket (e.g. "Basketball", "MMA", or "Soccer"). Existing semantics are unchanged; presentation consumers should prefer display_category when present. */
+    category: string;
+    /** Frozen public presentation category. For supported Polymarket sports this is the exact verified provider event identity: an official league (e.g. "WNBA" or "UFC"), the esports title (e.g. "CS2", "LoL", "Dota 2" or "Valorant"), or a soccer competition whose official mark we vendor (e.g. "LaLiga", "Premier League", "Serie A" or "UEFA Champions League"). Only identities with a vendored official mark are split out; every other competition keeps its canonical bucket, so "Soccer" remains a live value; otherwise it equals category. An esports pick keeps the pooled "Esports" bucket in category, so a per-title label never implies a per-title measured cohort. Additive and optional for mixed-version client compatibility. */
+    display_category?: string;
+    /** Provider (Polymarket Gamma) market thumbnail URL (markets.image); omitted (not null) when the market has no image. Public regardless of the backed-side gate, so present for pending rows too. */
+    image_url?: string;
+    /** The backed side's outcome label. Omitted for a still-pending pick when the request is not from an authenticated Pro key. */
+    pick_outcome_label?: string | null;
+    /** Best public V1-compatible S/A smart-money grade on the backed side; a current B-only grade is omitted by the stable V1 adapter, while historical rows retain their frozen policy's grade. null when no smart-money wallet backs the pick, when a pending legacy proof has not yet upgraded, or when the stored holder policy is unknown-future or structurally invalid. Resolved legacy history remains supported. */
+    top_grade?: string | null;
+    /** Settlement outcome of the backed side; 'pending' until the market resolves. */
+    outcome: "pending" | "win" | "loss" | "void";
+    /** Pre-formatted settlement status for display: "Win" / "Loss" / "Void" / "Pending" -- the outcome enum above as a label, from the same formatter the pick payload's outcome_display uses. Convenience only; outcome is the source value. */
+    outcome_display?: string;
+    /** Gross return on a $100 stake on this resolved pick: a win returns 100 / backed_price, a loss returns 0, a void refunds 100. A loss always returns 0 (the whole stake is lost regardless of price). Omitted (not null) only for a still-pending pick or a resolved WIN with no frozen price (a win's payout needs the price); mirrors the backend skip-when-absent behavior and the route-client optional (non-nullable) schema. */
+    return_per_100?: number;
+    /** Pre-formatted return_per_100 as USD with cents: "$200.00". Present exactly when return_per_100 is -- it is formatted from that already-gated value -- so it is omitted for a still-pending pick, an unpriced win, and any pick whose backed side is withheld. Convenience only; return_per_100 is the source value. */
+    payout_display?: string;
+    /** Closing-line value toward the backed side, computed as (close / entry - 1) * 100. Omitted when the row is gated, ineligible, or not measured. */
+    clv_pct?: number;
+    /** Backend-formatted signed CLV percentage, present exactly when clv_pct is present. */
+    clv_display?: string;
+    /** Whether CLV applies. A visible resolved pick published after kickoff is not_applicable. */
+    clv_applicability?: "applicable" | "not_applicable";
+    /** Backend-owned CLV formula text or the reason that CLV does not apply or is unavailable. */
+    clv_explanation?: string;
+    /** Exact backend CLV capture disposition for this visible row. Pending and terminal provider or quality statuses are distinguishable; raw close evidence is never serialized. */
+    clv_status: string;
+    /** Backend-owned CLV evidence basis. Source-null price-match bases preserve unknown original provenance. `historical_provider_nearby_price_match` requires a matching Polymarket point within five minutes before publication. */
+    clv_basis?: string;
+    /** Net return for this pick in stake units, where one unit is the existing $100 stake. Omitted when the backed side is withheld or the pick is not valued. */
+    unit_score?: number;
+    /** Backend-formatted signed unit score, present exactly when unit_score is present. */
+    unit_score_display?: string;
+};
+export type PickOfTheDayHitRate = {
+    /** Number of decided picks that won. */
+    wins: number;
+    /** Number of decided picks that lost. */
+    losses: number;
+    /** Number of decided picks (wins + losses); excludes void and pending. */
+    decided: number;
+    /** Rolling hit rate as a percentage (wins / decided * 100, to 1 decimal); 0 when none are decided. */
+    pct: number;
+    /** Number of picks that resolved void (excluded from the hit rate). */
+    void: number;
+    /** Number of picks still pending resolution (excluded from the hit rate). */
+    pending: number;
+    /** Cumulative profit (USD) of a $100/pick strategy over visible valued decided picks: a priced win pays 100/backed_price - 100, every visible loss pays -100 independent of price, and a void pays 0. An unpriced visible win and a current non-Insider row whose price is gated remain in wins/losses but are excluded from price-derived totals. */
+    net_profit_usd: number;
+    /** Total staked (USD) = 100 * count of visible valued decided picks: every visible loss plus every priced win. Void, unpriced wins, and current non-Insider rows whose price is gated are excluded. */
+    staked_usd: number;
+    /** Return on the staked amount as a percentage (net_profit_usd / staked_usd * 100, to 1 decimal); 0 when nothing is staked. */
+    roi_pct: number;
+    /** Pre-formatted net profit for display, e.g. "+$100" / "-$40". Whole dollars, signed, round-then-signed so a rounds-to-zero record reads "+$0" (never "-$0"). Convenience only; net_profit_usd is the source value. */
+    net_profit_display: string;
+    /** Pre-formatted ROI for display, e.g. "+8.3%" / "-20.0%". One decimal, signed, round-then-signed so a rounds-to-zero record reads "+0.0%" (never "-0.0%"). Convenience only; roi_pct is the source value. */
+    roi_display: string;
+    /** Pre-formatted win rate for display, e.g. "92.3%". One decimal, unsigned. Convenience only; pct is the source value. */
+    win_rate_display: string;
+    /** Cumulative net return in stake units over the same valued win/loss population as net_profit_usd. */
+    unit_score?: number;
+    /** Backend-formatted signed cumulative unit score, for example "+1.25u". Omitted when no valued settled pick contributes to the aggregate. */
+    unit_score_display?: string;
+    /** Visible resolved archive rows with no CLV capture disposition yet. */
+    clv_pending: number;
+    /** Visible resolved archive rows with a terminal non-measured CLV disposition. */
+    clv_unavailable: number;
+    /** Aggregate CLV state. Counts remain available for mixed measured/pending/unavailable populations. */
+    clv_state: "measured" | "pending" | "unavailable" | "not_applicable" | "none";
+    /** Visible resolved archive rows with valid basis-specific CLV entry evidence. Known-source bases require CLOB provenance; historical_provider_price_match instead requires source provenance to remain null and the latest provider p entry in the one-hour window at or before publication to match the stored display. */
+    clv_eligible: number;
+    /** Every visible resolved archive row, including post-kickoff picks. A price-gated current row is excluded until its backed side becomes visible. */
+    clv_total: number;
+    /** Eligible resolved public rows with a measured Polymarket CLOB close. */
+    clv_measured: number;
+    /** Visible resolved rows published before kickoff. This is the CLV coverage denominator. */
+    clv_applicable: number;
+    /** Visible resolved rows published after kickoff. These rows remain public but do not enter coverage. */
+    clv_not_applicable: number;
+    /** Measured divided by clv_applicable as a percentage. Omitted when clv_applicable is zero. */
+    clv_coverage_pct?: number;
+    /** Backend-formatted measured/clv_applicable coverage percentage. */
+    clv_coverage_display?: string;
+    /** Backend-owned coverage count text, including the excluded post-kickoff count. */
+    clv_coverage_explanation?: string;
+    /** Arithmetic mean of per-pick ratio CLV, (close / entry - 1) * 100. A cheap entry weighs more here than a favorite, so the headline average is clv_avg_pp; this field is kept for continuity. Suppressed until at least five measured rows exist. */
+    clv_avg_pct?: number;
+    /** Backend-formatted signed average CLV percentage, present when clv_avg_pct is present. */
+    clv_avg_display?: string;
+    /** Arithmetic mean of the measured closing-line move in percentage points, (close - entry) * 100, so every pick counts on the same scale. The headline CLV average. Covers the same measured rows as clv_avg_pct and is suppressed under the same five-row floor. */
+    clv_avg_pp?: number;
+    /** Backend-formatted signed average in percentage points, for example "+0.4 pp"; a value that rounds to zero reads "0.0 pp". Present when clv_avg_pp is present. */
+    clv_avg_pp_display?: string;
+    /** Measured public rows where close is strictly greater than entry. */
+    clv_beats_close: number;
+    /** Measured public rows where close exactly equals entry. */
+    clv_ties: number;
+    /** Cumulative track-record series, one point per decided (win/loss) pick in ascending pick_date order (void and pending add no point). A non-valued decided row carries cumulative profit forward while advancing hit rate. The last point's net_profit_usd and hit_rate_pct equal the headline net_profit_usd and pct by construction. Empty when nothing is decided. */
+    series?: {
+        /** The decided pick's publish date (YYYY-MM-DD). */
+        date: string;
+        /** Running cumulative $100/pick profit (USD) through this pick; valued losses and priced wins are booked, while a non-valued decided row carries profit forward unchanged. */
+        net_profit_usd: number;
+        /** Running rolling hit rate (wins / decided * 100, to 1 decimal) through this pick. */
+        hit_rate_pct: number;
+    }[];
+};
+/** Provider-first sports context for a Pick of the Day market: team crests, league branding, and live score. Team logos and league logo are provider-owned (Polymarket /teams crests for clubs, country flags for national teams and tennis players); no local derivation. */
+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. Separate from league_name; omitted when the provider does not supply the metadata. */
+    competition_label?: string | null;
+    /** 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;
+    /** The team mapped to the market's NO outcome, or the parent-event away/second team when event_matchup is true. */
+    no_team?: PickSportsTeam;
+    /** Provider game identifier (Polymarket Gamma gameId); omitted when null. */
+    game_id?: number | null;
+    /** 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 | null;
+};
+/** 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`, `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;
+    /** Full team or competitor name (e.g. "Portugal national football team"). */
+    full_name?: string | null;
+    /** Provider team identifier (Polymarket /teams id). */
+    provider_id?: number | null;
+    /** Team crest or flag URL. Provider-owned for most teams (Polymarket /teams crest for clubs, country flag for national teams and tennis players). A club with a vendored crest carries it instead, served same-origin as a relative path (`/api/sports/team-logos/{league}/{abbr}.svg?v=<content hash>` or `.png`, resolve it against this server): every NFL and WNBA team, whose provider asset is a text tile, and the soccer clubs whose provider asset is an empty object. */
+    logo?: string | null;
+    /** 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 | null;
+    /** 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 | null;
+};
+/** Field-level trust metadata for the full Pick of the Day payload. Present on the full shape only (omitted on the teaser and the no-pick state, because whether a specialist backs the pick is itself backed-side evidence). Unlike TraderTrust it is not gated behind expand=trust: it carries one member on an endpoint that returns a single object per day. */
+export type PickTrust = {
+    /** Provenance of the frozen qualifying category expert. source.kind=database with reconciliation.status=db_mirror means the evidence deserialized, still satisfies every frozen selection gate, and is being served. On that arm freshness.status is always not_live and never fresh, because this evidence is frozen at selection and never refreshed, so on an archived pick the as_of (the expert's own stats_computed_at) can be days or months old by design. source.kind=computed with reconciliation.status=not_applicable means the selector evaluated the backed side and nobody qualified -- a real negative. source.kind=computed with freshness.status=unknown and completeness.status=not_computed means the selector never evaluated this field, as on a pre-feature pick or manual takeover. source.kind=unavailable means the payload is malformed, violates a selection gate, or conflicts with its persisted status, or the public V1 adapter intentionally omitted a current-policy B-grade expert; read the reason before treating it as a negative. Do not read an omitted qualifying_expert as 'no specialist' without checking this field. */
+    qualifying_expert: TrustMetadata;
+};
+export type PlatformCapabilities = {
+    grade: PlatformCapabilityStatus;
+    pnl: PlatformCapabilityStatus;
+    strategy: PlatformCapabilityStatus;
+    timeline: PlatformCapabilityStatus;
+    whale_signal: PlatformCapabilityStatus;
+    insider_radar: PlatformCapabilityStatus;
+    market_snapshot: PlatformCapabilityStatus;
+};
+export type PlatformCapabilityStatus = "supported" | "partial" | "unsupported";
+export type Platforms = {
+    platforms: {
+        polymarket: PlatformCapabilities;
+    };
+};
+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 | null;
+    /** 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 | null;
+    /** Unrealized P&L for the open position (Polymarket `cashPnl`). */
+    cash_pnl?: number | null;
+    /** Closed-leg P&L rolled up (Polymarket `realizedPnl`). */
+    realized_pnl?: number | null;
+    /** Max updated_at across mirror legs for this pair. */
+    last_reconciled_at?: string | null;
+    /** Backend-computed staleness bucket derived from last_reconciled_at. */
+    freshness: "fresh" | "refreshing" | "stale" | "unknown";
+    trader: {
+        /** Prefixed ID (`trd_...`). */
+        id: string;
+        address: string;
+        username?: string | null;
+        grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Percentage 0-100. */
+        win_rate?: number | null;
+        pnl?: number | null;
+        markets?: number | null;
+        wallet_age_days?: number | null;
+        /** True when 0xinsider first recorded the wallet within the new-wallet threshold (30 days). This public V1 field is first-seen recency, not the wallet's on-chain age. */
+        is_new_wallet: boolean;
+    };
+    market: {
+        /** Prefixed ID (`mkt_...`). */
+        id: string;
+        condition_id: string;
+        title: string;
+        slug?: string | null;
+        event_slug?: string | null;
+        /** Provider-backed market_canonical category. */
+        category?: string | null;
+        /** Provider-reported outcome label (e.g. team name for sports). Separate from `side` because provider labels can diverge from the binary Yes/No axis. */
+        outcome_label?: string | null;
+        end_date?: string | null;
+    };
+};
+export type PositionTimelineEvent = {
+    /** Prefixed ID (pe_...). */
+    id: string;
+    /** ISO 8601 timestamp of the on-chain fill. */
+    event_timestamp: string;
+    /** From the taker's perspective. */
+    action: "buy" | "sell";
+    outcome_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;
+    /** Signed share delta (+ on buy, − on sell). */
+    amount_delta: number;
+    /** Fill price in USDC per share, in [0,1]. */
+    price: number;
+    /** Positive USDC notional of the fill. */
+    usdc_notional: number;
+    /** Polygon transaction hash of the fill. */
+    tx_hash: string;
+    /** Cumulative signed stored-fill amount for this outcome after this fill, including older pages. Stable across limits/cursors for unchanged source history. Excludes split, merge, redemption and neg-risk activity; not complete holdings. Incomplete fill history can also leave a negative amount. */
+    running_amount: number;
+    /** Cumulative buy-weighted average of stored fills for this outcome, including older pages; not provider current-position avgPrice. Sells do not change this value. 0 when no stored buys have occurred yet. */
+    running_avg_price: number;
+};
+/** Policy-7 issuance binds one condition, selected token, outcome, canonical event and sport. Reuse the same authorization across public/private discovery and retries. Require a new account-size executable book and current market eligibility; this frozen reference does not prove current liquidity or positive expected value. Absence or expiry cannot authorize a new automated entry. */
+export type PotdEntryAuthorization = {
+    version: 1;
+    authorization_id: string;
+    policy_version: 7;
+    condition_id: string;
+    token_id: string;
+    outcome_index: 0 | 1;
+    /** Canonical sport bucket, not display_category. */
+    category: string;
+    /** Exact provider parent event ID, or provider event ID when no parent exists. */
+    canonical_event_id: string;
+    /** Immutable decimal limit: first fresh selected-token ask plus 0.02, floored to the provider tick below 1. Fees excluded. Never a calibrated fair probability. */
+    max_entry_price: string;
+    reference_best_ask: string;
+    reference_book_hash: string;
+    reference_book_at: string;
+    issued_at: string;
+    /** Original provider kickoff ceiling. Never extended on retry. */
+    expires_at: string;
+};
+/** One PUBLISHED same-day pick whose holder proof is not readable yet: its stable slot rank, the release and kickoff instants, and the instant before which a retry cannot succeed. Every item in `picks` carries its full required shape, so a pick that cannot meet it is listed here instead of being served with missing fields or a synthetic zero. */
+export type ProofPendingPickSlot = {
+    /** Stable 1-based slot within the product day's ranked picks. The pick keeps this rank once its proof is readable and it moves into `picks`. */
+    pick_rank: number;
+    /** The pick's stored release instant. */
+    release_at: string;
+    /** The backed game's frozen kickoff instant; absent for a legacy row without one. */
+    kickoff?: string;
+    /** Recommended next read: 30 seconds ahead while pre-game proof is warming, one hour ahead for a post-kickoff pending legacy row that only settlement can make readable. Schedule against it instead of polling. */
+    retry_at: string;
+};
+export type RadarFlag = {
+    /** Prefixed ID (rf_...). */
+    id: string;
+    /** Stored score that met the live flag threshold. */
+    suspicion_score: number;
+    /** The live scorer persists one threshold class. */
+    severity: "flag";
+    trader: {
+        id: string;
+        address: string;
+        username?: string | null;
+    };
+    market: {
+        id: string;
+        condition_id: string;
+        /** Canonical market question when available. */
+        title: string | null;
+    };
+    scores: {
+        /** Null because the live scorer does not record this component. */
+        timing?: number | null;
+        /** Null because the live scorer does not record this component. */
+        edge?: number | null;
+        /** Numeric evidence.size when recorded; otherwise null. */
+        size?: number | null;
+        /** Numeric evidence.fresh when recorded; otherwise null. */
+        fresh_wallet?: number | null;
+    };
+    /** Stored whale_alerts.suspicion_signals JSON from the scorer. */
+    evidence: unknown;
+    /** Stored trade timestamp. */
+    created_at: string;
+};
+export type ReportPayload = {
+    total_whale_trades?: number | null;
+    total_whale_volume?: number | null;
+    biggest_trade_size?: number | null;
+    active_traders?: number | null;
+    top_whale_trades?: ({
+        /** Provider outcome label for the traded side. */
+        outcome?: string | null;
+        /** Trade direction (BUY or SELL), not the outcome side. */
+        side?: string | null;
+        /** Market title. */
+        title?: string | null;
+        /** Trade size in USD. */
+        size?: number | null;
+        /** Trade price in provider [0, 1] units. */
+        price?: number | null;
+        /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the traded outcome; null when unavailable (e.g. unsynced markets). */
+        token_id?: string | null;
+        /** Whale trade id. */
+        id?: number | null;
+        /** Trade timestamp (UTC). */
+        trade_time?: string | null;
+        /** Provider market category. */
+        market_category?: string | null;
+        /** Venue: polymarket. */
+        platform?: string | null;
+        /** Trader display name, when known. */
+        name?: string | null;
+        /** Trader pseudonym, when no display name is known. */
+        pseudonym?: string | null;
+        /** Trader grade (S-F) at snapshot time. */
+        trader_grade?: string | null;
+    })[] | null;
+    categories?: Record<string, unknown>[] | null;
+    grade_distribution?: Record<string, unknown>[] | null;
+};
+export type ReportReconciliation = {
+    volume_kind: "local_whale_activity_volume";
+    whale_volume_source: "whale_alerts.usdc_notional_num";
+    notes: string;
+};
+export type ReportSnapshot = {
+    kind: "daily" | "weekly" | "monthly";
+    generated_at: string;
+    source_range: ReportSourceRange;
+    snapshot: SnapshotState;
+    completeness: SnapshotCompleteness;
+    reconciliation: ReportReconciliation;
+    report: ReportPayload;
+};
+export type ReportSourceRange = {
+    start_date: string;
+    end_date: string;
+    timezone: "UTC";
+};
+export type ResponseMeta = {
+    /** Unique request ID (req_ prefix). */
+    request_id: string;
+    cached: boolean;
+    /** Cache age in seconds. Omitted when the response was not cached, and also when it was cached but its age cannot be established (an entry stored before its cache carried a computed instant). Never a placeholder: an unknown age is reported as no value rather than as the cache TTL. */
+    cache_age_s?: number | null;
+    /** Advisory request weight (relative compute cost). 1 for simple reads; higher for heavier endpoints. Not a credit/price. */
+    cost: number;
+    /** Committed PostgreSQL-owned leaderboard generation for the returned rows and cursor. Present on GET /api/v1/leaderboard; omitted on endpoints that do not read this ranking. */
+    ranking_generation?: number | null;
+    /** Authoritative RFC3339 timestamp from cache_generations.updated_at for ranking_generation. It is read in the same repeatable-read snapshot as the leaderboard rows and is not request time, cache write time, or row insertion order. */
+    ranking_as_of?: string | null;
+    /** Which path produced the team-directional read on this response. Only present on endpoints that compute one (today: GET /api/v1/sports-edge-signals). "live" means the read RAN. "degraded" means it FAILED, so nothing was measured and the ranking fell back to raw conviction. The flag describes the READ, not its consequence: a read that ran and found nothing groupable also leaves the directional fields null, and that is honestly "live" -- the per-signal nulls already say "nothing to enrich here", so this snapshot-level flag carries only what they cannot, namely whether the read ran at all. A degraded response is cached on the shorter degraded TTL so it self-heals. Reported SEPARATELY from ranking_source because the two degradations are independent -- a smart-money DB miss weakens the ranking DATA, a directional failure removes a ranking WEIGHT -- and a consumer down-weighting a degraded response needs to know which input it lost. Omitted on endpoints that compute no directional read. */
+    directional_source?: "live" | "degraded";
+    /** Which ranking-data path produced this response. Only present on endpoints that can degrade a ranking (today: GET /api/v1/sports-edge-signals). "live" is the normal path (the current holder pile from the provider batch); "db_only" is the degraded fallback (a truthful but weaker trader_markets ranking) served when the live sharp-money ranking batch is unavailable (a smart-money DB read failure, not a Polymarket outage) and cached on a shorter TTL, so a consumer can down-weight or skip it. Omitted on endpoints that never degrade. */
+    ranking_source?: "live" | "db_only";
+    /** Whole filtered snapshot category-evidence status before pagination. Operational live always remains partial source coverage. */
+    category_skill_source?: "live" | "partial" | "degraded" | "unavailable";
+    category_skill_model_version?: string;
+    category_skill_taxonomy_version?: string;
+    category_skill_platform?: "polymarket";
+    category_skill_scope?: "observed_goldsky_primary_taker_fill";
+    category_skill_source_coverage?: "partial_whale_threshold_fills" | "graded_wallet_fills";
+    category_skill_observation_started_at?: string;
+    /** Whole-model operational readiness captured with the category model snapshot. Present on category-enriched responses even when the filtered signal list is empty. When true, category_skill_source is degraded and sports-edge-signals uses the shorter degraded cache TTL. */
+    category_skill_model_operationally_degraded?: boolean;
+    category_skill_status_counts?: {
+        live: number;
+        insufficient: number;
+        stale: number;
+        unknown: number;
+        degraded: number;
+    };
+    /** SHA-256 of the funded signal membership/order/rank/cursor vector immediately before category-skill enrichment. Sports-edge-signals only. */
+    category_skill_base_payload_hash?: string;
+    /** Independent SHA-256 recomputation over the same base fields immediately after category-skill enrichment. Equality with category_skill_base_payload_hash proves shadow enrichment did not change funded inputs. Sports-edge-signals only. */
+    category_skill_enriched_base_payload_hash?: string;
+};
+/** One same-day pick that is selected but not yet released: its stable slot rank plus the backend-owned release and kickoff instants. Deliberately minimal -- no matchup, category, platform, side, price, or holder fields exist on this shape before release. */
+export type ScheduledPickSlot = {
+    /** Stable 1-based slot within the product day's ranked picks. The slot keeps this rank when it releases. */
+    pick_rank: number;
+    /** The slot's scheduled release instant, normally the current provider kickoff minus one hour. The actual publish can trail it by bounded worker delay. */
+    release_at: string;
+    /** The backed game's current kickoff instant. */
+    kickoff: string;
+};
+/** One side's score in a single set. The verbatim provider text stays on the team's `score` string; this is the parsed form. */
+export type ScoreCell = {
+    /** Games won in this set. */
+    games: number;
+    /** Tiebreak points won in this set. Omitted when the set had no tiebreak; absence and zero are different. */
+    tiebreak?: number;
+};
+/** Shape the provider score string was parsed into. `two_side` is one aggregate per side (basketball `105-98`), `multi_set` is per-set columns (tennis `6-7(5-7), 6-0, 1-0`), `esports_series` is a maps/sets/format triplet (`000-000|2-0|Bo3`). Omitted when the score could not be parsed. */
+export type ScoreFormat = "two_side" | "multi_set" | "esports_series";
+export type SmartMoneyFlowMarket = {
+    market: {
+        id: string;
+        condition_id: string;
+        title: string | null;
+        slug: string | null;
+        category: string | null;
+        platform: string | null;
+    };
+    /** Sharp-money flow aggregate for the market (canonical; smart_money is a deprecated byte-identical alias). */
+    sharp_money: {
+        net_flow_usd: number;
+        direction: "YES" | "NO";
+        /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the net-flow direction outcome; null when unavailable (e.g. unsynced markets). */
+        token_id?: string | null;
+        whale_trade_count: number;
+        buy_volume_usd: number;
+        sell_volume_usd: number;
+    };
+    /** Deprecated alias of sharp_money; byte-identical and retained for backward compatibility. */
+    smart_money: {
+        net_flow_usd: number;
+        direction: "YES" | "NO";
+        /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the net-flow direction outcome; null when unavailable (e.g. unsynced markets). */
+        token_id?: string | null;
+        whale_trade_count: number;
+        buy_volume_usd: number;
+        sell_volume_usd: number;
+    };
+    timeframe: string;
+};
+export type SnapshotCompleteness = {
+    status: "complete" | "partial" | "empty";
+    reason: string;
+    expected_days: number;
+    covered_days_with_whale_activity: number;
+};
+export type SnapshotState = {
+    /** Immutable content version for this report identity. */
+    version: number;
+    status: "final" | "rolling";
+    generated_at: string;
+    mutable_until?: string | null;
+};
+/** Per-sport accountable funnel for the full observation snapshot, returned on every page. */
+export type SportsEdgeFunnelReport = {
+    sports: SportsEdgeSportFunnelReport[];
+};
+/** One explicitly observation-only holder-pile measurement. It is evidence for cohort evaluation, not an execution instruction, and is isolated from the funded sports-edge-signals route. */
+export type SportsEdgeObservation = {
+    /** Raw Polymarket condition id. */
+    condition_id: string;
+    /** Provider-backed Polymarket CLOB token id for the piled outcome. Rows without a verified token terminate before emission. */
+    token_id: string;
+    /** Canonical sport bucket. */
+    category: "Basketball" | "Football" | "Baseball" | "Hockey" | "MMA" | "Boxing" | "Soccer" | "Cricket" | "Golf" | "Tennis" | "Esports" | "Racing" | "Table Tennis" | "Pickleball";
+    /** Raw provider category as stored. */
+    raw_category: string | null;
+    /** Provider-backed market title. */
+    title: string;
+    event_slug: string | null;
+    /** Provider event id when available. */
+    event_id: string | null;
+    /** Provider parent-event id used as the first event-cap identity when available. */
+    parent_event_id: string | null;
+    /** Provider-backed kickoff time in UTC. */
+    game_start_time: string;
+    /** UTC instant when this row finished provider/holder evaluation. */
+    observed_at: string;
+    /** Source cohort or additive projection view. emerging_pile is projected from wider_holder after source computation, overlaps its funnel denominator, and uses the source row's directional evidence. */
+    cohort: "wider_holder" | "in_play" | "emerging_pile";
+    /** Always true. This row must not be routed to an order executor. */
+    observation_only: true;
+    /** Nullable provider-backed piled-outcome display label. When provider group context is unavailable, it may remain a bare Yes/No/Over/Under; do not use it alone as participant identity. */
+    piled_side: string | null;
+    /** Provider binary-column selector: 0 selects outcome_yes/token_id_yes; 1 selects outcome_no/token_id_no. It does not identify home/away or a participant. Use piled_side together with title/event context for display. */
+    piled_outcome_index: 0 | 1;
+    /** Provider-backed implied price for the piled outcome at observation time. */
+    backed_price: number;
+    /** Piled-side graded-holder dollar concentration. */
+    sharp_pct: number;
+    /** Raw graded-holder USD on the piled outcome. */
+    backed_sharp_usd: number;
+    s_count: number;
+    a_count: number;
+    b_count: number;
+    /** Piled-side S/A/B holder count. */
+    graded_holders: number;
+    top_grade: "S" | "A" | "B";
+    /** Canonical signed holder-pile score. */
+    smart_score: number;
+    /** Strictly positive stored market volume in USD. Missing, zero, or non-finite volume terminates as invalid_market and is never emitted as an observation. */
+    volume: number;
+    /** Grade-weighted holder-pile score before directional enrichment. */
+    conviction_score: number;
+    /** Whether the provider holder page came from the shared cache or a live provider read. */
+    provider_read_source: "cached" | "live";
+    /** True only when neither provider outcome holder page hit the top-100 scan bound. False means the pile is a positive lower bound and cannot satisfy a future capital-promotion gate. */
+    holder_scan_complete: boolean;
+    /** Proven provider holder observation time. A warm cache hit uses only the original provider completion time from its companion metadata, never cache-read time. Null, malformed, future, or stale holder time fails in-play closed. */
+    holder_snapshot_at: string | null;
+    /** Truthful state of the directional read, which classifies each graded holder by its fresh synced legs across the game's markets and, when holder_scan_complete is true, by Polymarket's currentValue on both outcomes of this market. A wider_holder row can remain emitted with unavailable and terminal wider_holder_emitted; in_play fails closed instead and terminates as in_play_directional_unavailable. */
+    directional_status: "available" | "unknown_ungrouped" | "unknown_stale" | "unavailable";
+    one_way_holder_count: number | null;
+    hedged_holder_count: number | null;
+    one_way_graded_usd: number | null;
+    directional_confidence: number | null;
+    /** Default cohort ordering key: conviction_score * (1 + 0.25 * directional_confidence), or conviction_score when confidence is null. */
+    directional_rank_score: number;
+    /** 1-based rank within this observation cohort and snapshot. */
+    rank: number;
+};
+/** Closed 25-value terminal-reason vocabulary for the accountable sports-edge observation funnel. capacity_limited is intentional bounded provider-work admission and does not itself set the snapshot degraded. board_source_unavailable is a completed board-source failure; board_deadline_unavailable means live-board work missed either an internal configured-scope deadline or the outer fair-wave deadline; both classify only already-started rows, so for the upcoming source read funnel.sports[].board_upcoming_status instead; provider_unavailable is reserved for an attempted holder-provider failure; holder_deadline_unavailable is holder cache/provider absolute-deadline exhaustion. */
+export type SportsEdgeObservationTerminalReason = "outside_horizon" | "resolved" | "provider_closed" | "provider_excluded" | "invalid_market" | "missing_token" | "missing_stored_market" | "not_provider_live" | "board_source_unavailable" | "board_deadline_unavailable" | "primary_slate_candidate" | "zero_indexed_holder_research" | "capacity_limited" | "provider_unavailable" | "holder_deadline_unavailable" | "holder_computation_unavailable" | "holder_scan_incomplete" | "no_current_graded_holder" | "split_holder_pile" | "price_unavailable" | "wider_holder_emitted" | "in_play_emitted" | "in_play_stale_observed" | "in_play_directional_unavailable" | "internal_unclassified";
+/** One ranked pre-game sports market where graded sharp money is piled on one side, with required-status shadow category evidence from partial forward-observed Polymarket fills. */
+export type SportsEdgeSignal = {
+    /** Polymarket condition id. */
+    condition_id: string;
+    /** UTC time at which the immutable signal snapshot was computed. Every row from one snapshot shares this value; it is not provider market creation time and is not rewritten at request time. */
+    signal_created_at: string;
+    /** Polymarket CLOB token id (ERC1155 asset id, decimal string) for the PILED outcome; null when unavailable. */
+    token_id?: string | null;
+    /** Canonical sport bucket (e.g. Basketball, Tennis); null when the raw category has no canonical mapping. */
+    category?: string | null;
+    /** Raw provider category as stored (e.g. NBA, EPL). */
+    raw_category?: string | null;
+    title?: string | null;
+    event_slug?: string | null;
+    /** Kickoff (UTC). In the future at SNAPSHOT time and within the requested horizon; because the response is served from a shared snapshot cached up to the ~180s TTL, a served kickoff can be up to ~180s in the past relative to the response time. Not a live guarantee that the game has not yet started. */
+    game_start_time?: string | null;
+    /** Nullable provider-backed piled-outcome display label. When provider group context is unavailable, it may remain a bare Yes/No/Over/Under; do not use it alone as participant identity. */
+    piled_side?: string | null;
+    /** Provider binary-column selector: 0 selects outcome_yes/token_id_yes; 1 selects outcome_no/token_id_no. It does not identify home/away or a participant. Use piled_side together with title/event context for display. */
+    piled_outcome_index: number;
+    /** Piled-side dollar concentration backed_usd / (yes_usd + no_usd), in (0.5, 1] for a real pile; null when there is no sharp USD. */
+    sharp_pct?: number | null;
+    /** Raw piled-side sharp-money USD. */
+    backed_sharp_usd: number;
+    /** S-grade graded holders on the piled side. */
+    s_count: number;
+    /** A-grade graded holders on the piled side. */
+    a_count: number;
+    /** B-grade graded holders on the piled side. */
+    b_count: number;
+    /** Piled-side graded holder count (s_count + a_count + b_count). */
+    graded_holders: number;
+    /** Best grade present on the piled side; null when none. */
+    top_grade?: "S" | "A" | "B";
+    /** Canonical sharp-money score (yes_usd - no_usd)/(yes_usd + no_usd) in [-1, 1] (piled-yes positive, piled-no negative); a lower-order ranking tiebreak (after directional_rank_score and conviction_score). */
+    smart_score?: number | null;
+    /** Market volume (USD). */
+    volume?: number | null;
+    /** Aggregate recent flow direction on the market; null when unavailable. */
+    net_side?: "BUY" | "SELL";
+    /** Grade-weighted pile score (5*s + 4*a + 3*b) * sharp_pct; the raw conviction input to the ranking (see directional_rank_score). */
+    conviction_score: number;
+    /** Piled-side graded holders read one-way: their fresh open legs across the signal game's markets (cross-market within the one game; moneyline+spread family only) all back the same team, or, when the market's holder scan was complete, Polymarket's currentValue shows no opposite leg on this market worth 10% of the backed leg and no fresh leg opposes it. Null when the directional read was not computed (no groupable game, no holder-level data on this ranking path, or the enrichment read failed) or classified nobody. */
+    one_way_holder_count?: number | null;
+    /** Piled-side graded holders classified HEDGED across the game by fresh legs (they back two or more distinct teams). A wallet long both outcomes of this market is not one-way and not counted here. Null when the directional read was not computed or classified nobody. */
+    hedged_holder_count?: number | null;
+    /** Piled-side graded USD held by one-way wallets (share-weighted allocation of backed_sharp_usd). Null when the directional read was not computed or classified nobody. */
+    one_way_graded_usd?: number | null;
+    /** One-way fraction of the piled graded dollars, in [0, 1] -- the metric orthogonal to sharp_pct. Stale, unknown, hedged, and two-sided dollars dilute it toward zero (conservative). Null when the directional read was not computed or classified nobody. */
+    directional_confidence?: number | null;
+    /** The ranking key, descending: conviction_score * (1 + 0.25 * directional_confidence). Equals conviction_score when the directional read is null/zero, so signals without the read rank exactly as before. */
+    directional_rank_score: number;
+    category_skill: SportsEdgeSignalCategorySkill;
+    /** 1-based rank within the (min_grade-filtered) ranked result. */
+    rank: number;
+};
+/** Shadow-only category evidence over the full uncapped piled-side S/A/B holder allocation. It never changes signal membership, ordering, routing, or sizing. */
+export type SportsEdgeSignalCategorySkill = {
+    status: "live" | "insufficient" | "stale" | "unknown" | "degraded";
+    model_version: string;
+    taxonomy_version: string | null;
+    platform: "polymarket";
+    scope: "observed_goldsky_primary_taker_fill";
+    source_coverage: "partial_whale_threshold_fills" | "graded_wallet_fills";
+    observation_started_at: string;
+    as_of: string;
+    canonical_category: string | null;
+    eligible_holders: number;
+    covered_holders: number;
+    backed_sharp_usd: number | null;
+    covered_backed_usd: number | null;
+    coverage_pct: number | null;
+    weighted_edge_mean: number | null;
+    weighted_holder_lower_mean: number | null;
+    specialist_backed_usd: number | null;
+    specialist_backed_usd_pct: number | null;
+    largest_holder_backed_usd_pct: number | null;
+    minimum_holder_event_count: number | null;
+};
+/** Independent sports-board supply plus stored-universe terminal accounting for one canonical sport. */
+export type SportsEdgeSportFunnelReport = {
+    sport: "Basketball" | "Football" | "Baseball" | "Hockey" | "MMA" | "Boxing" | "Soccer" | "Cricket" | "Golf" | "Tennis" | "Esports" | "Racing" | "Table Tennis" | "Pickleball";
+    /** Unique condition ids independently visible on the provider-first sports board. */
+    board_input: number;
+    /** Whether the always-applicable live-board source completed as available. False can mean a completed source failure (board_source_unavailable) or live-board work missing an internal configured-scope deadline or the outer fair-wave deadline (board_deadline_unavailable); inspect terminals to distinguish them. */
+    board_live_available: boolean;
+    /** Whether a provider-backed upcoming-board source is configured and applicable for this sport. False means not applicable, not provider failure. */
+    board_upcoming_configured: boolean;
+    /** Whether every configured upcoming-board scope completed as available. False with board_upcoming_configured=false means not applicable. When board_upcoming_configured is true and this flag is false, read board_upcoming_status for the cause (it reads unknown, i.e. no recorded cause, only on a snapshot cached before that field existed, which self-clears within one TTL): the board_source_unavailable and board_deadline_unavailable terminals are assigned only to already-started rows (the live half) and are structurally 0 for the upcoming source, so they never explain this flag. */
+    board_upcoming_available: boolean;
+    /** Why the upcoming-board source is (un)available. Board supply is one canonical-sport union: the bare category owns live truth and every configured composed league scope contributes upcoming rows; folded leagues without a configured board (currently NCAAB and CFL) are not in the upcoming union. available: every configured scope completed truthfully (a successful empty schedule still counts). capacity_limited: provider pagination or a configured upcoming cache published an intentionally bounded complete-event prefix; those rows are excluded from diagnostic-universe input and must not be treated as a complete upcoming universe. Cache-bound prefixes are limited to 3,000 rows or an exact 5,000,000-byte final envelope. source_unavailable: composition failed before a truthful union; resolved scope readers turn half failures into cold_unavailable, so fresh producers are whole-union identity reconciliation or a registry contract failure and carry zero rows. cold_unavailable: every scope completed but at least one reported its upcoming half unavailable because no servable entry was inside the stale-serve bound and the background warm did not land in time; it is not by itself proof of a provider outage. deadline_unavailable: an internal configured-scope deadline or the outer bounded fair wave expired. An internal deadline may retain healthy bare-category or sibling-scope rows; the outer wave records zero rows. These upcoming fields do not describe league live-membership availability. If the bare-category live scope fails, all live rows are dropped even when a league scope completed, because the bare category is the sole live-truth owner. not_configured: no upcoming scope applies to the sport. unknown: exactly one cause -- a snapshot cached before this field existed whose legacy flags recorded an unavailable-but-configured half without saying why. Every freshly computed snapshot reports a concrete status, and a legacy available or not-configured row is reconstructed exactly, so unknown self-clears within one TTL. board_upcoming_available is exactly board_upcoming_status == available. */
+    board_upcoming_status: "unknown" | "not_configured" | "available" | "capacity_limited" | "source_unavailable" | "cold_unavailable" | "deadline_unavailable";
+    /** Configured upcoming scopes that did not complete as available. Values are category, a provider league tag slug (nfl, cfb, nba, wnba, nhl, mls, valorant, league-of-legends, counter-strike-2, or dota-2), registry when the compiled scope/projection contract drifted, union when cross-scope identity reconciliation failed, or wave when the outer fair-wave deadline expired before scope-level evidence returned. Empty means no unavailable upcoming scope was identified; this includes healthy/not-configured rows and a legacy cached row. Observation league scopes are upcoming-only and perform no live-membership read. */
+    board_upcoming_unavailable_scopes: ("category" | "nfl" | "cfb" | "nba" | "wnba" | "nhl" | "mls" | "valorant" | "league-of-legends" | "counter-strike-2" | "dota-2" | "registry" | "union" | "wave")[];
+    /** Stored-universe rows plus provider-board rows missing from storage. */
+    input: number;
+    /** Sparse counts over the closed 25-value terminal vocabulary: outside_horizon, resolved, provider_closed, provider_excluded, invalid_market, missing_token, missing_stored_market, not_provider_live, board_source_unavailable, board_deadline_unavailable, primary_slate_candidate, zero_indexed_holder_research, capacity_limited, provider_unavailable, holder_deadline_unavailable, holder_computation_unavailable, holder_scan_incomplete, no_current_graded_holder, split_holder_pile, price_unavailable, wider_holder_emitted, in_play_emitted, in_play_stale_observed, in_play_directional_unavailable, or internal_unclassified. primary_slate_candidate means exact admission by the funded route's raw shared signals query before provider/holder enrichment; recent-flow rows rejected by its event, bucket, or total caps remain eligible for wider_holder measurement. capacity_limited is intentional bounded provider-work admission, is fully accounted here, and does not itself set degraded=true. board_source_unavailable means a completed board source was unavailable; board_deadline_unavailable means live-board work missed either an internal configured-scope deadline or the outer fair-wave deadline; provider_unavailable means an attempted holder-provider read failed; holder_deadline_unavailable means holder cache/provider work missed the absolute request deadline; holder_computation_unavailable means post-holder provider or DB-backed price/metadata evaluation was unavailable. */
+    terminals: Record<string, number>;
+    /** Sum of every sparse terminal count. */
+    terminal_total: number;
+    /** True exactly when input equals terminal_total. */
+    reconciled: boolean;
+};
+export type Trader = {
+    /** Prefixed ID (trd_...). */
+    id: string;
+    address: string;
+    username?: string | null;
+    grade?: "S" | "A" | "B" | "C" | "D" | "F";
+    /** Hot-streak tier (trailing-7d cross-sectional percentile); a separate axis from the all-time grade. Null when no recent activity. */
+    streak_tier?: "hot" | "rising" | "neutral" | "cooling" | "cold";
+    score?: number | null;
+    rank?: number | null;
+    pnl: {
+        total?: number | null;
+        /** For pnl.realized, expand=trust marks a matching native accounting snapshot as computed: native Polymarket realized P&L plus credited maker and taker rebates, with fees already included. Without a matching native accounting snapshot, pnl.realized is omitted and its trust metadata is unavailable. Raw total P&L is never substituted for realized P&L. */
+        realized?: number | null;
+        unrealized?: number | null;
+        /** DEPRECATED, always null. The local pnl_7d rollup over-counted P&L (#5416 class) and is no longer emitted. Read the provider-native weekly window from GET /api/trader/{address}/profile-summary instead. */
+        last_7d?: number | null;
+        /** DEPRECATED, always null. The local pnl_30d rollup over-counted P&L (#5416 class) and is no longer emitted. Read the provider-native monthly window from GET /api/trader/{address}/profile-summary instead. */
+        last_30d?: number | null;
+    };
+    stats: {
+        markets_traded?: number | null;
+        win_rate?: number | null;
+        daily_win_rate?: number | null;
+        total_volume?: number | null;
+    };
+    strategy?: {
+        strategy_type?: string;
+        description?: string | null;
+        confidence?: number | null;
+    } | null;
+    /** Per-category performance breakdown (expand=categories or expand[]=categories). Omitted unless expanded. Object keyed by category name; each value is the precomputed trader_rankings.category_ranks payload (rank, total_in_category, total_pnl, scaled_total_pnl, n_markets, wins, losses, win_rate; scaled_total_pnl is a legacy alias that currently equals total_pnl). Pass-through DB JSON: keys and value shape are DB-owned, so the inner shape is intentionally unconstrained and may carry additional compatibility fields. */
+    category_strengths?: Record<string, unknown> | null;
+    /** Curated advanced risk/performance metrics (expand=quant_metrics or expand[]=quant_metrics). Omitted unless expanded and backed by a computed row strictly under six hours old; a missing row, NULL computed_at, or age of exactly six hours or more is stale and omitted. Provider-input changes may intentionally lag inside the bounded six-hour window. When present, all listed fields are present (each is a number or null); null means insufficient trade history and must not be treated as 0. The fixed field shape is unchanged. */
+    quant_metrics?: {
+        /** Composite skill score, 0-100. smart_score = clamp(0, 100, 30*sharpe_percentile_fraction + 20*profit_factor_percentile_fraction + 20*edge_consistency_percentile_fraction + 10*min(1, return_on_capital/2) + 10*equity_smoothness + 10*(1 - min(1, asset_concentration))). Higher is better. null when insufficient history. */
+        smart_score: number | null;
+        /** Copyability score, 0-100. Same base as smart_score minus penalties for traits that make a strategy hard to replicate: -20 if fewer than 50 markets traded, -15 if positions are highly concentrated, -15 if position sizing exceeds about 2x Kelly, -10 if the worst single-trade loss exceeds 30%, -10 if edge is inconsistent; result clamped to 0-100. Higher means easier to follow. null when insufficient history. */
+        copy_score: number | null;
+        /** Sharpe ratio over the trailing 30 days (risk-adjusted return; higher is better). Magnitude can be large for small samples. null when insufficient history. */
+        sharpe_30d: number | null;
+        /** Sharpe ratio over the trailing 7 days (risk-adjusted return; higher is better). null when insufficient history. */
+        sharpe_7d: number | null;
+        /** Gross profit divided by gross loss; greater than 1 is profitable. Capped at 1000 when there are effectively no losses. null when insufficient history. */
+        profit_factor: number | null;
+        /** Stability of the trader's edge over time, 0-1 (higher is more consistent). null when insufficient history. */
+        edge_consistency: number | null;
+        /** Cross-sectional percentile rank of the trader's Sharpe ratio versus all traders, 0-100. null when insufficient history. */
+        sharpe_percentile: number | null;
+        /** Cross-sectional percentile rank of profit factor versus all traders, 0-100. null when insufficient history. */
+        pf_percentile: number | null;
+        /** Cross-sectional percentile rank of edge consistency versus all traders, 0-100. null when insufficient history. */
+        consistency_percentile: number | null;
+    } | null;
+    last_active?: string | null;
+    synced_at?: string | null;
+    /** synced, unknown, or pending. */
+    sync_status?: string | null;
+    /** Field-level trust metadata. Present only when expand=trust or expand[]=trust is requested. */
+    trust?: TraderTrust;
+};
+export type TraderContext = {
+    trader: Trader;
+    /** Aggregate position and P&L coverage for the trader. Omitted entirely (key absent, never null) when the trader is not in the local database or native net economics is unavailable. Realized fields remain numbers when present, including a genuine zero. */
+    position_summary?: {
+        /** Provider markets_traded count when known; null when the provider total is unavailable. */
+        markets_total: number | null;
+        /** Markets with locally synced position rows. */
+        markets_synced: number;
+        /** Synced markets that have resolved. */
+        markets_resolved: number;
+        /** Synced markets still open with residual value (open positions with current value > 0). */
+        markets_open: number;
+        /** markets_synced divided by markets_total when the provider total is known (capped at 1.0); 0.0-1.0. When markets_total is unknown or not positive (null, 0, or negative), this is 1.0 if any markets are synced (else 0.0), so cross-check markets_total before treating 1.0 as full coverage. */
+        sync_coverage: number;
+        /** Native net realized P&L (USD) including credited rebates, minus the stored realized component of open positions with positive current value. Rebates are credited to the account, not to a position, so every credited rebate stays in this figure. NUMERIC arithmetic precedes conversion to a JSON number. */
+        synced_realized_pnl: number;
+        /** Native net realized P&L (USD) including credited rebates, read directly from the accounting snapshot. Position sync_coverage is separate from this accounting basis. */
+        total_realized_pnl: number;
+        /** Mark-to-market unrealized P&L (USD) on open positions. */
+        unrealized_mtm: number;
+        /** Cost basis (USD) currently tied up in open positions. */
+        cost_basis_locked: number;
+        /** Win rate as a percentage (0-100): resolved_wins over resolved_decided. A resolved market that settled at exactly zero realized P&L (a void, a refund, a fully hedged position) is neither a win nor a loss and is not in the denominator, the same rule the leaderboard applies; null when no resolved market was decided. */
+        resolved_win_rate: number | null;
+        /** Resolved markets that settled at positive realized P&L: the win-rate numerator. Additive; null only on a summary cached before the field existed. */
+        resolved_wins?: number | null;
+        /** Resolved markets that settled at a non-zero realized P&L: the win-rate denominator. At most markets_resolved; the difference is markets settled at exactly zero or with an unknown P&L. Additive; null only on a summary cached before the field existed. */
+        resolved_decided?: number | null;
+        /** RFC3339 freshness of the served OPEN-position data: the trader's latest /positions snapshot, else the last completed sync. The snapshot advances ONLY open positions, so read this as the open-position freshness clock -- the resolved/closed aggregates on this same summary (markets_resolved, resolved_win_rate) advance only on a full sync. The value is the /positions snapshot instant when one exists, so it is typically at or just before the trader-level last sync on a normal sync, and can be AFTER it while the active-view loop refreshes open positions between full syncs. This clock does not establish native accounting freshness. Always present on the wire (serialized as JSON null when the trader has neither a snapshot nor a sync); never omitted. */
+        as_of: string | null;
+    };
+    /** RFC3339 freshness of the OPEN-position-level data: when a position_summary is present this mirrors its as_of byte-for-byte (latest /positions snapshot, else last completed sync) -- the open-position freshness clock, since the snapshot advances only open positions; otherwise the trader's last completed sync, even if an unserved position snapshot exists. Null when the selected clock is unavailable; a missing breakdown does not establish position or accounting freshness. */
+    data_as_of: string | null;
+    /** 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 date to the last full sync; native realized P&L follows its accounting snapshot -- not a live feed; re-fetch for fresher data). */
+    freshness_note: string;
+};
+export type TraderExportJob = {
+    object: "trader_export_job";
+    data: {
+        job_id: number;
+        status: "queued" | "running" | "ready" | "failed";
+        format: "json" | "ndjson" | "csv";
+        total_trades?: number | null;
+        processed_trades?: number | null;
+        file_size?: number | null;
+        error?: string | null;
+    };
+    meta: ResponseMeta;
+};
+export type TraderExportSnapshot = {
+    address: string;
+    generated_at: string;
+    source_range: ExportSourceRange;
+    completeness: ExportCompleteness;
+    reconciliation: ExportVolumeReconciliation;
+    counts: ExportCounts;
+    large_export_policy: LargeExportPolicy;
+};
+export type TraderPnl = {
+    /** Prefixed trader ID (`trd_...`). */
+    id: string;
+    /** RFC3339 served-freshness clock for this trader's PnL history = traders.daily_pnl_recomputed_at, when the daily_pnl read model this response is served from was last rebuilt; null when it has never been recomputed for the trader. Additive optional (not in `required`). */
+    freshness_at?: string | null;
+    /** Daily cumulative-P&L series (oldest-first). */
+    entries: ({
+        date: string;
+        markets_traded?: number | null;
+        total_volume?: number | null;
+        cumulative_profit?: number | null;
+        total_pnl?: number | null;
+        daily_change: number;
+    })[];
+    stats: {
+        all: {
+            current: number;
+            change: number;
+            change_pct: number;
+            best_day: number;
+            best_day_date?: string | null;
+            worst_day: number;
+            worst_day_date?: string | null;
+            win_days: number;
+            loss_days: number;
+            avg_day: number;
+            rebase_anchor: number;
+        };
+        d90: {
+            current: number;
+            change: number;
+            change_pct: number;
+            best_day: number;
+            best_day_date?: string | null;
+            worst_day: number;
+            worst_day_date?: string | null;
+            win_days: number;
+            loss_days: number;
+            avg_day: number;
+            rebase_anchor: number;
+        };
+        d30: {
+            current: number;
+            change: number;
+            change_pct: number;
+            best_day: number;
+            best_day_date?: string | null;
+            worst_day: number;
+            worst_day_date?: string | null;
+            win_days: number;
+            loss_days: number;
+            avg_day: number;
+            rebase_anchor: number;
+        };
+        d7: {
+            current: number;
+            change: number;
+            change_pct: number;
+            best_day: number;
+            best_day_date?: string | null;
+            worst_day: number;
+            worst_day_date?: string | null;
+            win_days: number;
+            loss_days: number;
+            avg_day: number;
+            rebase_anchor: number;
+        };
+    };
+    /** Per-month P&L aggregation. */
+    monthly: {
+        year: number;
+        month: number;
+        pnl: number;
+        markets_traded: number;
+    }[];
+    /** Per-year P&L totals (ascending by year). */
+    year_totals: {
+        year: number;
+        pnl: number;
+    }[];
+    /** Underwater (drawdown) series. */
+    drawdown: {
+        date: string;
+        cumulative_profit: number;
+        drawdown: number;
+    }[];
+};
+/** Field-level trust metadata returned only when GET /api/v1/trader/{address} includes expand=trust. */
+export type TraderTrust = {
+    total_pnl: TrustMetadata;
+    realized_pnl: TrustMetadata;
+    unrealized_pnl: TrustMetadata;
+    markets_traded: TrustMetadata;
+    win_rate: TrustMetadata;
+    daily_win_rate: TrustMetadata;
+    total_volume: TrustMetadata;
+    grade: TrustMetadata;
+    score: TrustMetadata;
+    rank: TrustMetadata;
+    streak_tier: TrustMetadata;
+    strategy: TrustMetadata;
+    category_strengths: TrustMetadata;
+    quant_metrics: TrustMetadata;
+    last_active: TrustMetadata;
+    synced_at: TrustMetadata;
+    sync_status: TrustMetadata;
+};
+export type TrendingWallet = {
+    /** Prefixed trader ID (`trd_...`). */
+    id: string;
+    address: string;
+    /** 1-based rank within the full ranked set (stable across pages). */
+    rank: number;
+    username?: string | null;
+    /** Official Polymarket avatar URL (profileImage). */
+    profile_image_url?: string | null;
+    /** Real provider platform; surfaced, never coerced. Polymarket-only today. */
+    platform: "polymarket";
+    /** Polymarket weekly/monthly P&L for the wallet in USD, taken from Polymarket's canonical leaderboard (data-api.polymarket.com/v1/leaderboard?timePeriod=week|month&orderBy=PNL). This is the ranking axis and the rows are returned in Polymarket's by-PNL order; it is the provider's number, not a locally summed realized-leaf total. */
+    trending_pnl_usd: number;
+    window_volume_usd: number;
+    window_markets_traded: number;
+    /** Distinct in-window UTC trade days from our trades (0 if the winner is not in our DB). */
+    window_trade_days: number;
+    /** All-time trader grade; a separate axis from streak_tier. Led by realized profit (the money actually banked, about 95 percent of the grade), with forecasting calibration, risk-adjusted returns, and consistency as the tie-breaker and proven-trader guardrails: any grade above C requires verified net-positive realized profit, and the top grades also require a real resolved-market track record plus a survivable drawdown. Relative, so it drifts as the cohort moves. Omitted when the trader is Unranked (fewer than 5 markets, or too little verified record to cohort-rank). */
+    grade?: "S" | "A" | "B" | "C" | "D" | "F";
+    /** Hot-streak tier (trailing-7d cross-sectional percentile). Null when no recent activity. */
+    streak_tier?: "hot" | "rising" | "neutral" | "cooling" | "cold";
+    all_time_pnl_usd?: number | null;
+    all_time_score?: number | null;
+    last_synced?: string | null;
+    /** Shape-only daily P&L sparkline across the window, derived from Polymarket's documented user-pnl cumulative curve (GET /v2/user-pnl) converted to per-day deltas. It conveys the trend of the curve only and is NOT guaranteed to sum to trending_pnl_usd, which is the canonical leaderboard total. */
+    daily_pnl_series: {
+        date: string;
+        pnl_usd: number;
+    }[];
+};
+/** Whether the described value or result set is complete for its stated contract. */
+export type TrustCompleteness = {
+    status: "complete" | "partial" | "not_computed" | "not_applicable" | "unavailable";
+    detail?: string | null;
+};
+/** Freshness metadata for a trust-critical value. This is separate from transport cache fields in ResponseMeta. */
+export type TrustFreshness = {
+    status: "fresh" | "refreshing" | "stale" | "not_live" | "unknown" | "unavailable";
+    as_of?: string | null;
+    max_age_s?: number | null;
+};
+/** Shared source/freshness/reconciliation/completeness metadata for public API values that may be cached, stale, partial, computed, or provider-unavailable. Unavailable provider values must be represented with explicit metadata instead of fabricated zeros or empty arrays. */
+export type TrustMetadata = {
+    source: TrustSource;
+    freshness: TrustFreshness;
+    reconciliation: TrustReconciliation;
+    completeness: TrustCompleteness;
+};
+/** How provider-owned facts were reconciled with stored/read-model values. */
+export type TrustReconciliation = {
+    status: "provider_backed" | "db_mirror" | "computed" | "partial" | "not_applicable" | "unavailable";
+    detail?: string | null;
+};
+/** Source metadata for a trust-critical value. Providers and DB/read models own business truth; clients should not infer missing provider facts from titles, slugs, zeros, or empty arrays. */
+export type TrustSource = {
+    kind: "provider" | "database" | "cache" | "computed" | "client_input" | "unavailable";
+    /** Provider, table/read-model, cache, or service that owns the value. */
+    owner: string;
+    /** Provider field, DB column, or computed field name when applicable. */
+    field?: string | null;
+};
+export type UpdateWebhookRequest = {
+    name?: string;
+    /** Replacement public HTTPS callback URL on the default port 443, validated and checked for uniqueness exactly like the create url. HTTPS scheme/host case, trailing DNS dots and port 443 normalize; path/query case is preserved. Changing it resets status to pending_verification and returns a new verification token; the new destination must pass the verification challenge before deliveries resume. */
+    url?: string;
+    event_types?: WebhookEventType[];
+    enabled?: boolean;
+};
+export type Usage = {
+    object: "usage";
+    data: {
+        rate_limit: {
+            used: number;
+            limit: number;
+            remaining: number;
+            reset_at: number;
+            window_seconds: number;
+        };
+        /** UTC-day usage count. Current V1 has no daily hard cap, so limit and remaining are null rather than synthesized. */
+        daily_usage: {
+            used: number;
+            limit: number | null;
+            remaining: number | null;
+            reset_at: number;
+            window_seconds: number;
+        };
+    };
+    meta: ResponseMeta;
+};
+export type VerifyWebhookRequest = {
+    /** The one-time token returned on create or on a url change. It is necessary but not sufficient: the destination must also answer the signed webhook.verification challenge with a 2xx. */
+    verification_token: string;
+};
+/** Owner-scoped view of one webhook delivery attempt. Deliberately omits the request body and the endpoint signing secret: a delivery log never re-exposes the payload or any secret material. */
+export type WebhookDelivery = {
+    id: number;
+    object: "webhook_delivery";
+    /** Stable event id for this delivery; identical across retries of the same logical event. */
+    event_id: string;
+    event_type: WebhookEventType;
+    /** Delivery lifecycle state (e.g. pending, delivered, dead_letter). */
+    status: string;
+    /** Number of delivery attempts made so far. */
+    attempt_count: number;
+    /** HTTP status code of the most recent delivery attempt. Omitted until a response (or transport error) has been recorded. */
+    last_response_status?: number;
+    /** Short description of the most recent delivery failure. Omitted when the last attempt succeeded or none has failed. */
+    last_error?: string;
+    /** When the delivery was first accepted by the destination. Omitted until a delivery succeeds. */
+    delivered_at?: string;
+    /** When the next delivery attempt is due, for a delivery whose status is pending or retry. null while an attempt is in flight (processing) and once the delivery is terminal (delivered or dead_letter). */
+    next_attempt_at: string | null;
+    created_at: string;
+};
+export type WebhookEndpoint = {
+    id: number;
+    object: "webhook";
+    name: string;
+    url: string;
+    event_types: WebhookEventType[];
+    status: WebhookStatus;
+    verified_at?: string | null;
+    verification_token_expires_at: string;
+    failure_count: number;
+    created_at: string;
+    updated_at: string;
+    retry_policy: WebhookRetryPolicy;
+    /** Returned only on create or rotate-secret. */
+    signing_secret?: string;
+    verification?: WebhookVerification;
+};
+/** Self-describing entry in the webhook event catalog: the event type a subscriber lists in event_types, when it fires, the data payload shape, and whether it currently fires (active) or is reserved (dormant, subscribable but not yet delivered). Pro-only event types (whale_trades_inserted, wallet_grade_changed, insider_radar_flag_raised, smart_money_flow_detected) only deliver to API keys on an active Pro subscription. */
+export type WebhookEventDescriptor = {
+    id: WebhookEventType;
+    /** One-line description of when the event fires. */
+    description: string;
+    /** Short description of the data payload object's shape. */
+    payload_shape: string;
+    /** active: the event has a firing producer callsite. dormant: advertised and subscribable, but does not yet enqueue any delivery. */
+    status: "active" | "dormant";
+};
+export type WebhookEventType = "whale_trades_inserted" | "live_sports_updated" | "whale_trader_synced" | "large_positions_updated" | "wallet_grade_changed" | "insider_radar_flag_raised" | "smart_money_flow_detected";
+export type WebhookRetryPolicy = {
+    max_attempts: 8;
+    terminal_status: "dead_letter";
+    /** Total wait from a delivery's first failed attempt to its last retry: 60, 120, 240, 480, 960, 1920 and 3600 seconds. A delivery still failing after that is dead_letter. */
+    retry_horizon_seconds: 7380;
+    /** Consecutive failed attempts, across all of this endpoint's deliveries, after which the endpoint is disabled and its queued deliveries are dead-lettered. Any successful attempt resets the count. */
+    disable_after_consecutive_failures: 8;
+};
+export type WebhookStatus = "pending_verification" | "active" | "disabled";
+export type WebhookVerification = {
+    /** One-time verification token returned only on create or URL change. Pass it to POST /api/v1/webhooks/{id}/verify, which activates the endpoint only when the destination also answers the signed webhook.verification challenge with a 2xx. */
+    token: string;
+    expires_at: string;
+};
+export type WhaleTrade = {
+    /** Prefixed ID (wt_...). */
+    id: string;
+    traded_at: string;
+    size_usd: number;
+    side: "BUY" | "SELL";
+    /** Traded outcome label (e.g. "Yes"/"No"/team name), resolved provider-first from the trade's outcome_index against market_canonical (index 0 -> yes, 1 -> no). Distinct axis from side (BUY/SELL): side is the trade direction, outcome is which leg was traded. null for multi-outcome (outcome_index >= 2) or unsynced markets, and for a Polymarket trade recorded before 2026-04-02T00:00:00Z, whose stored outcome_index is not trusted (a defaulted 0 for about a third of those rows; the side is unknown, not defaulted). */
+    outcome?: string | null;
+    /** The Polymarket CLOB token id (ERC1155 asset id, decimal string) for the traded outcome; null when unavailable (e.g. unsynced markets) and for a Polymarket trade recorded before 2026-04-02T00:00:00Z, where the traded side is unknown. */
+    token_id?: string | null;
+    price: number;
+    /** Current 0.0–1.0 normalized signal score. This value can change as scoring context changes. */
+    signal_score: number;
+    /** 0.0–1.0 signal score written once when the trade row is inserted. Available for new rows after this field launched; legacy rows return null. If a trade is added later, its time-sensitive recorded score reflects that delay. */
+    recorded_signal_score: number | null;
+    /** Persisted live suspicion score from the scorer. Null when the row has no persisted score. */
+    suspicion_score: number | null;
+    /** Persisted scorer track. Null when a legacy row has no stored track label. */
+    suspicion_track: "whale" | "fresh_conviction" | "sliced_position";
+    /** This fill's size relative to its market: size_usd divided by the market's volume at the moment the trade was inserted. A $10,000 fill is 0.00005 of a $200M market and 0.125 of an $80,000 one, which size_usd alone cannot distinguish. Absent when the market carried no volume figure and on rows written before 2026-09-16; never 0 as a stand-in. Not capped at 1: a fill larger than the stored trailing volume is real, and that is the most significant case. */
+    market_volume_share?: number;
+    trader: {
+        id: string;
+        address: string;
+        username?: string | null;
+        grade?: string | null;
+    };
+    market: {
+        id: string;
+        condition_id: string;
+        title: string;
+        slug?: string | null;
+        /** Provider-backed market_canonical category. */
+        category?: string | null;
+    };
+};
+export type WhaleTradeDetail = WhaleTrade & {
+    counterparty_analysis: CounterpartyAnalysis;
+};
+export type WhaleTradeHistoryMeta = {
+    /** Unique request ID (req_ prefix). */
+    request_id: string;
+    cached: boolean;
+    /** Cache age in seconds, null if not cached. */
+    cache_age_s?: number | null;
+    source: {
+        kind: "local_replay";
+        table: "whale_alerts";
+        provider_fetch_at_request_time: false;
+    };
+    completeness: {
+        status: "best_effort";
+        /** Explains that local replay completeness can vary by market and time window. */
+        reason: string;
+    };
+};
+/**
+ * The `data` payload each operation answers with: what
+ * `ApiClient.call<T>` resolves to, and the default `T` of every
+ * convenience method.
+ */
+export interface OperationData {
+    batchGetMarketIntel: BatchMarketIntelItem[];
+    batchGetTraders: BatchTraderItem[];
+    createMcpJsonRpcResponse: {
+        jsonrpc: "2.0";
+        id: string | number | null;
+        result?: Record<string, unknown>;
+        error?: {
+            code: number;
+            message: string;
+        };
+    };
+    createWebhook: WebhookEndpoint;
+    deleteWebhook: WebhookEndpoint;
+    exploreMarkets: ExploreEntry[];
+    getAccountIdentity: {
+        user_id: number;
+        credential_id: number;
+        credential_kind: "api_key" | "oauth_grant";
+        /** Approved OAuth scopes; null for full developer-key access. */
+        scopes: string[] | null;
+    };
+    getApiDiscovery: ApiDiscovery;
+    getDailyReportSnapshot: ReportSnapshot;
+    getEventReplaySince: EventReplayEvent[];
+    getHealth: {
+        status?: "ok" | "degraded" | "down" | "maintenance";
+        db?: boolean;
+        cache?: boolean;
+        subsystems?: {
+            /** Public-safe aggregate status for expected background job successful-completion heartbeats. Does not expose Redis keys, job names, raw errors, provider payloads, wallet addresses, or condition IDs. */
+            background_jobs: {
+                status: "ok" | "degraded" | "down" | "not_checked";
+                checked: boolean;
+                total: number;
+                healthy: number;
+                stale: number;
+                missing: number;
+                invalid: number;
+                unconfigured: number;
+                /** Heavy-periodic jobs that are stale/missing/invalid while the heavy executor is disabled (heavy_pipeline_control.executor_mode != 'active'), so this binary does not dispatch them. Observable but expected; they never drive status to 'down' (paused > 0 yields 'degraded'). */
+                paused: number;
+            };
+        };
+    };
+    getInsiderRadarFlag: RadarFlag;
+    getMarketCandles: MarketCandles;
+    getMarketContextMarkdown: string;
+    getMarketIntel: MarketIntel;
+    getMarketSnapshot: MarketSnapshot;
+    getMonthlyReportSnapshot: ReportSnapshot;
+    getPickOfTheDay: PickOfTheDay;
+    getPickOfTheDayArchive: PickOfTheDayArchive;
+    getPlatforms: Platforms;
+    getPositionTimeline: PositionTimelineEvent[];
+    getPositionTimelineById: PositionTimelineEvent[];
+    getReports: ReportSnapshot;
+    getStream: string;
+    getTrader: Trader;
+    getTraderContext: TraderContext;
+    getTraderContextMarkdown: string;
+    getTraderExportSnapshot: TraderExportSnapshot;
+    getTraderExportStatus: {
+        job_id: number;
+        status: "queued" | "running" | "ready" | "failed";
+        format: "json" | "ndjson" | "csv";
+        total_trades?: number | null;
+        processed_trades?: number | null;
+        file_size?: number | null;
+        error?: string | null;
+    };
+    getTraderPnl: TraderPnl;
+    getUsage: {
+        rate_limit: {
+            used: number;
+            limit: number;
+            remaining: number;
+            reset_at: number;
+            window_seconds: number;
+        };
+        /** UTC-day usage count. Current V1 has no daily hard cap, so limit and remaining are null rather than synthesized. */
+        daily_usage: {
+            used: number;
+            limit: number | null;
+            remaining: number | null;
+            reset_at: number;
+            window_seconds: number;
+        };
+    };
+    getWebhook: WebhookEndpoint;
+    getWeeklyReportSnapshot: ReportSnapshot;
+    getWhaleTrade: WhaleTradeDetail;
+    listInsiderRadar: RadarFlag[];
+    listLargePositions: LargePosition[];
+    listLeaderboard: LeaderboardEntry[];
+    listPositions: Position[];
+    listSharpMoneyFlows: SmartMoneyFlowMarket[];
+    listSmartMoneyFlows: SmartMoneyFlowMarket[];
+    listSportsEdgeObservations: SportsEdgeObservation[];
+    listSportsEdgeSignals: SportsEdgeSignal[];
+    listTrendingWallets: TrendingWallet[];
+    listWebhookDeliveries: WebhookDelivery[];
+    listWebhookEvents: WebhookEventDescriptor[];
+    listWebhooks: WebhookEndpoint[];
+    listWhaleTradeCounterpartyExecutions: CounterpartyAnalysis;
+    listWhaleTradeCounterpartyMakers: CounterpartyMakerPage;
+    listWhaleTradeHistory: WhaleTrade[];
+    listWhaleTrades: WhaleTrade[];
+    openMcpEventStream: string;
+    redeliverWebhookDelivery: WebhookDelivery;
+    rotateWebhookSecret: WebhookEndpoint;
+    searchContent: ContentSearchResult[];
+    searchMarkets: MarketSearchResult[];
+    submitTraderExport: {
+        job_id: number;
+        status: "queued" | "running" | "ready" | "failed";
+        format: "json" | "ndjson" | "csv";
+        total_trades?: number | null;
+        processed_trades?: number | null;
+        file_size?: number | null;
+        error?: string | null;
+    };
+    updateWebhook: WebhookEndpoint;
+    verifyWebhook: WebhookEndpoint;
+}
+/** Each operation's documented query parameters. */
+export interface OperationQuery {
+    batchGetMarketIntel: Record<string, never>;
+    batchGetTraders: Record<string, never>;
+    createMcpJsonRpcResponse: {
+        /** Legacy API-key query parameter for exact /api/v1/mcp only. Every other protected V1 route rejects it. Prefer Authorization: Bearer <token> or the stdio package because URL secrets are easier to leak through logs and history. The retirement date is unknown until external URL-only client compatibility is checked. */
+        token?: string;
+    };
+    createWebhook: 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. */
+        category?: string;
+        /** Filter by market status. */
+        status?: "active" | "closed" | "all";
+        /** Filter by source platform. Explore is Polymarket-only; polymarket is the only supported value and the parameter is accepted for backward-compatibility but does not change the result set. */
+        platform?: "polymarket";
+        /** Sort order for the discovery feed. */
+        sort?: "trending" | "hot" | "expiring" | "whales" | "volume" | "newest";
+        /** Opaque pagination cursor from the previous response. */
+        cursor?: string;
+        /** Page size. */
+        limit?: number;
+        /** Keyword search against market titles. At most 64 characters before whitespace trimming. */
+        q?: string;
+    };
+    getAccountIdentity: Record<string, never>;
+    getApiDiscovery: Record<string, never>;
+    getDailyReportSnapshot: {
+        /** UTC report date in YYYY-MM-DD format. */
+        date: string;
+    };
+    getEventReplaySince: {
+        /** Opaque event replay cursor returned as next_cursor by a prior response. The cursor maps to whale_alerts.id and is valid across backend replicas. Omit to fetch the latest durable public suffix. */
+        cursor?: string;
+        /** Maximum durable public whale-trade events to return. */
+        limit?: number;
+    };
+    getHealth: Record<string, never>;
+    getInsiderRadarFlag: Record<string, never>;
+    getMarketCandles: {
+        /** Bucketing granularity. 1d aggregates by UTC calendar day, 1w by ISO week (Monday 00:00 UTC start). Defaults to 1d. */
+        resolution?: "1d" | "1w";
+        /** Exclusive lower bound as a unix timestamp in seconds; points at or before this timestamp are omitted (the underlying daily snapshot read filters bucket_start > from). Note: for resolution=1w a surviving mid-week point can yield a weekly candle whose t (Monday 00:00 UTC) precedes from. */
+        from?: number;
+        /** Inclusive upper bound as a unix timestamp in seconds; points after this timestamp are omitted. */
+        to?: number;
+    };
+    getMarketContextMarkdown: Record<string, never>;
+    getMarketIntel: {
+        /** Lookback window for whale flow aggregation. */
+        timeframe?: "1h" | "4h" | "24h" | "7d";
+    };
+    getMarketSnapshot: {
+        /** Backward-compatible alias for expand. Repeatable: trust. */
+        "expand[]"?: "trust"[];
+        /** Include trust metadata for current_price and spread_bps. Repeatable: trust. */
+        expand?: "trust"[];
+    };
+    getMonthlyReportSnapshot: {
+        /** UTC report month in YYYY-MM format. */
+        month: string;
+    };
+    getPickOfTheDay: Record<string, never>;
+    getPickOfTheDayArchive: Record<string, never>;
+    getPlatforms: Record<string, never>;
+    getPositionTimeline: {
+        /** Market condition_id. One timeline per (trader, market). */
+        condition_id: string;
+        /** Maximum number of timeline events to return. */
+        limit?: number;
+        /** Pagination cursor from previous response's next_cursor. */
+        cursor?: string;
+    };
+    getPositionTimelineById: {
+        /** Market condition_id. One timeline per (trader, market). */
+        condition_id: string;
+        /** Maximum number of timeline events to return. */
+        limit?: number;
+        /** Pagination cursor from previous response's next_cursor. */
+        cursor?: string;
+    };
+    getReports: {
+        /** Report granularity selector. */
+        granularity: "daily" | "weekly" | "monthly";
+        /** Period token for the granularity. daily: UTC date YYYY-MM-DD. weekly: ISO week YYYY-WW, or a from,to YYYY-MM-DD pair. monthly: UTC month YYYY-MM. */
+        period: string;
+    };
+    getStream: {
+        /** Query-string fallback for the Last-Event-ID resume cursor when the client cannot set the request header. Numeric cluster-shared sequence id; non-numeric or absent attaches live with no replay. A future or expired id emits resync. */
+        last_event_id?: string;
+        /** Alias for last_event_id. Numeric cluster-shared sequence id to resume after; non-numeric or absent attaches live with no replay. A future or expired id emits resync. */
+        seq?: string;
+        /** Optional per-connection subscribe-time filter. Comma-separated list of frame wire types (the SSE 'type' discriminator, e.g. WhaleTradesInserted,wallet_grade_changed); a frame passes only when its type is in the set. An unknown token returns HTTP 400 naming the offending value. An empty/all-whitespace value is treated as absent (no constraint). Applied to BOTH the replay window and live frames, and always AFTER the per-subscriber privacy gate, so it can never widen visibility beyond what the key may already see. Combines with condition_id and min_grade as a logical AND; an absent param adds no constraint. */
+        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 that carry no grade field (every frame except wallet_grade_changed) are EXCLUDED while this is set. An invalid grade returns HTTP 400. Combines with event and condition_id as a logical AND; an absent param adds no constraint. */
+        min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+    };
+    getTrader: {
+        /** Backward-compatible alias for expand. Repeatable: strategy, categories, quant_metrics, trust. */
+        "expand[]"?: ("strategy" | "categories" | "quant_metrics" | "trust")[];
+        /** Include heavy fields and trust metadata. Repeatable: strategy, categories, quant_metrics, trust. */
+        expand?: ("strategy" | "categories" | "quant_metrics" | "trust")[];
+    };
+    getTraderContext: Record<string, never>;
+    getTraderContextMarkdown: Record<string, never>;
+    getTraderExportSnapshot: Record<string, never>;
+    getTraderExportStatus: {
+        /** Export job id returned by the submit route. */
+        job_id: number;
+    };
+    getTraderPnl: Record<string, never>;
+    getUsage: Record<string, never>;
+    getWebhook: Record<string, never>;
+    getWeeklyReportSnapshot: {
+        /** UTC source-range start in YYYY-MM-DD format; required with to. */
+        from?: string;
+        /** UTC source-range end in YYYY-MM-DD format; required with from. */
+        to?: string;
+        /** ISO week selector in YYYY-WW format; alternative to from/to. */
+        week?: string;
+    };
+    getWhaleTrade: Record<string, never>;
+    listInsiderRadar: {
+        /** Maximum number of radar flags to return. */
+        limit?: number;
+        /** Pagination cursor from previous response. */
+        cursor?: string;
+        /** Minimum suspicion score (0-100). The live flag floor of 60 also applies. */
+        min_suspicion?: number;
+        /** Compatible filter. flag selects live threshold crossings. watch returns no rows because no live watch policy exists. */
+        severity?: "flag" | "watch";
+    };
+    listLargePositions: {
+        /** Maximum number of large positions to return. */
+        limit?: number;
+        /** Opaque pagination cursor from a previous response. */
+        cursor?: string;
+        /** Minimum position value in USD. */
+        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. */
+        category?: string;
+        /** Minimum trader grade. */
+        min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Scope to one market. Accepts the raw provider condition_id or the mkt_-prefixed market id (round-trips a value from a list response). Polymarket-only; an unknown id returns []. */
+        condition_id?: string;
+    };
+    listLeaderboard: {
+        /** Maximum number of ranked traders to return. */
+        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; legacy, malformed, non-finite, and unsupported-version cursors are rejected. */
+        cursor?: string;
+        /** Filter by category. Values are matched to canonical category buckets: political variants (Elections, Global Politics, U.S. Politics, ...) fold into Politics, Geopolitics stays distinct, Culture/Entertainment map to Pop Culture, Science maps to Science & Tech, and Finance/Business map to Stocks. Mapped buckets are case-insensitive; passthrough categories (Crypto, NBA, and the sports leagues) match case-sensitively against the provider-native bucket key, so use exact casing (e.g. Crypto, NBA). */
+        category?: string;
+        /** Filter by ML-detected strategy type. Values come from backend/crates/analytics/src/trader_analysis/classification/decision_tree.rs and are matched exactly against ml_trader_category.primary_type. Values outside the declared enum return HTTP 400. */
+        strategy?: "accumulator" | "algo_trader" | "arbitrageur" | "directional" | "event_driven" | "market_maker" | "momentum" | "scalper" | "speculator" | "swing_trader";
+    };
+    listPositions: {
+        /** Maximum number of current positions to return. */
+        limit?: number;
+        /** Pagination cursor from previous response's next_cursor. */
+        cursor?: string;
+        /** Minimum current position value in USD. */
+        min_size?: number;
+        /** Exact match against provider-backed market_canonical.category. */
+        category?: string;
+        /** Minimum trader grade allowlist. `A` matches S and A; `B` matches S, A, B; etc. */
+        min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Filter by the binary outcome side. `yes` maps to outcome_index=0, `no` to outcome_index=1. */
+        side?: "yes" | "no";
+    };
+    listSharpMoneyFlows: {
+        /** Lookback window for grade-filtered whale flow aggregation. */
+        timeframe?: "1h" | "4h" | "24h" | "7d";
+        /** Page size. */
+        limit?: number;
+        /** Opaque cursor from previous response's next_cursor. Encodes the first-page as_of timestamp plus the last row's absolute net flow and condition_id. */
+        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. */
+        category?: string;
+        /** Filter by source platform. all is a request-side no-op. */
+        platform?: "polymarket" | "all";
+        /** Minimum latest trader grade included in the flow. Default B means S/A/B only; unranked traders are excluded. */
+        min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Optional post-aggregate flow direction filter. */
+        direction?: "YES" | "NO";
+    };
+    listSmartMoneyFlows: {
+        /** Lookback window for grade-filtered whale flow aggregation. */
+        timeframe?: "1h" | "4h" | "24h" | "7d";
+        /** Page size. */
+        limit?: number;
+        /** Opaque cursor from previous response's next_cursor. Encodes the first-page as_of timestamp plus the last row's absolute net flow and condition_id. */
+        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. */
+        category?: string;
+        /** Filter by source platform. all is a request-side no-op. */
+        platform?: "polymarket" | "all";
+        /** Minimum latest trader grade included in the flow. Default B means S/A/B only; unranked traders are excluded. */
+        min_grade?: "S" | "A" | "B" | "C" | "D" | "F";
+        /** Optional post-aggregate flow direction filter. */
+        direction?: "YES" | "NO";
+    };
+    listSportsEdgeObservations: {
+        /** Observation cohort. wider_holder measures pre-game holder piles outside the funded route's exact raw signals admission. in_play admits only provider-confirmed live games and excludes stale or unavailable provider live-board, holder, or directional evidence. emerging_pile is a post-compute wider_holder projection for finite sharp_pct in [0.75, 0.85) with holder_scan_complete=true and a kickoff after its pinned projection cutoff; it overlaps wider_holder, is not an independent denominator, and is not arrival history. */
+        cohort: "wider_holder" | "in_play" | "emerging_pile";
+        /** Optional canonical sport bucket. Omitted or blank selects all registered sports. Raw provider categories resolve through the canonical taxonomy, including table-tennis or table tennis to Table Tennis and pickleball to Pickleball; a non-sport category returns an empty list. */
+        category?: string;
+        /** Page size. */
+        limit?: number;
+        /** Server-authenticated opaque seo_v2_ cursor from next_cursor. Pins snapshot_as_of, cohort, rank, and condition_id; pre-deploy unsigned seo_ cursors are rejected, so clients must request the first page after this contract ships; emerging_pile cursors also pin the first-page projection_now cutoff so kickoff filtering cannot renumber continuation pages. Client edits fail closed; it cannot cross cohorts; a refreshed snapshot invalidates it with 400. */
+        cursor?: string;
+    };
+    listSportsEdgeSignals: {
+        /** Optional canonical sport bucket filter (e.g. Basketball, Tennis, Soccer). A raw provider value (NBA) resolves to its canonical bucket. A non-sport category returns an empty list. */
+        category?: string;
+        /** Page size. */
+        limit?: number;
+        /** Opaque cursor from a previous response's next_cursor. Encodes the snapshot anchor plus the last row's directional_rank_score, conviction_score, smart_score and condition_id. A cursor from an expired snapshot returns 400. */
+        cursor?: string;
+        /** Kickoff ceiling in hours from now; the floor is now (only games not yet started). Clamped to 1..48. */
+        horizon_hours?: number;
+        /** Minimum trader grade required on the piled side. Only S, A, B are accepted (the piled-side grade distribution is S/A/B only; C, D, F return 400). Default B means at least one S/A/B holder is piled; S requires an S holder, A requires an S or A holder. */
+        min_grade?: "S" | "A" | "B";
+    };
+    listTrendingWallets: {
+        /** Polymarket's weekly leaderboard caps the ranked set at 50 wallets; requests above 50 still return at most 50. */
+        limit?: number;
+        /** Opaque pagination cursor from a previous response. */
+        cursor?: string;
+        /** Trailing window. */
+        window?: "7d" | "30d";
+    };
+    listWebhookDeliveries: {
+        /** Opaque pagination cursor returned as next_cursor by a prior response. Omit to fetch the newest page. */
+        cursor?: string;
+        /** Maximum delivery rows to return per page. */
+        limit?: number;
+    };
+    listWebhookEvents: Record<string, never>;
+    listWebhooks: Record<string, never>;
+    listWhaleTradeCounterpartyExecutions: {
+        /** Counterparty snapshot ID from the whale trade detail response. */
+        snapshot_id: string;
+        /** Opaque cursor from the previous response's next_cursor. */
+        cursor?: string;
+        /** Maximum number of counterparty execution rows to return. */
+        limit?: number;
+    };
+    listWhaleTradeCounterpartyMakers: {
+        /** Counterparty snapshot ID from the whale trade detail response. */
+        snapshot_id: string;
+        /** Opaque cursor from the previous response's next_cursor. */
+        cursor?: string;
+        /** Maximum number of maker rows to return. */
+        limit?: number;
+    };
+    listWhaleTradeHistory: {
+        /** Maximum number of historical large trades to return. */
+        limit?: number;
+        /** Pagination cursor from previous response's next_cursor. Prefix: wth_. URL-encode when replaying as a query parameter. */
+        cursor?: string;
+        /** Minimum trade size in USD. */
+        min_size?: number;
+        /** Exact raw provider condition_id. Unknown markets return an empty list. */
+        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. */
+        category?: string;
+        /** Minimum trader grade. */
+        min_grade?: "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. */
+        platform?: "polymarket" | "all";
+        /** Inclusive RFC3339 lower bound on whale_alerts.traded_at. */
+        from?: string;
+        /** Exclusive RFC3339 upper bound on whale_alerts.traded_at. Must be after from when both are present. */
+        to?: string;
+    };
+    listWhaleTrades: {
+        /** Maximum number of recent large trades to return. */
+        limit?: number;
+        /** Pagination cursor from previous response's next_cursor. */
+        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. */
+        category?: string;
+        /** Minimum trader grade. */
+        min_grade?: "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;
+    };
+    openMcpEventStream: {
+        /** Legacy API-key query parameter for exact /api/v1/mcp only. Every other protected V1 route rejects it. Same contract as POST. */
+        token?: string;
+    };
+    redeliverWebhookDelivery: Record<string, never>;
+    rotateWebhookSecret: Record<string, never>;
+    searchContent: {
+        /** Search query. Must be 1-256 characters before whitespace trimming and non-empty after trimming. */
+        q: string;
+        /** Maximum content items to return. */
+        limit?: number;
+    };
+    searchMarkets: {
+        /** Search query. Must be 1-512 characters before whitespace trimming and non-empty after trimming. */
+        q: string;
+        /** Maximum number of matching markets to return. */
+        limit?: number;
+        /** Pagination cursor from previous response's next_cursor. */
+        cursor?: string;
+        /** Filter by market status. */
+        status?: "active" | "closed" | "all";
+        /** Filter by category. */
+        category?: string;
+    };
+    submitTraderExport: {
+        /** Output serialization. json = full envelope document (default); ndjson = full envelope as line 1 then one trade object per line; csv = flat trades rows only. */
+        format?: "json" | "ndjson" | "csv";
+    };
+    updateWebhook: Record<string, never>;
+    verifyWebhook: Record<string, never>;
+}
+//# sourceMappingURL=schema.d.ts.map