@0xinsider/sdk 0.14.0-bootstrap.0

package/dist/client.d.ts

@@ -0,0 +1,1652 @@
+/**
+ * Standalone 0xinsider API V1 client.
+ *
+ * Ported from the app's original repo-owned client (`web/src/lib/api-client`,
+ * removed in #9060; this package is now the sole client implementation). The
+ * `API_CLIENT_OPERATIONS` table below IS the contract surface:
+ * `scripts/check-sdk-openapi-drift.mjs` asserts it equals the set of operations
+ * with a `200` response in `web/public/api/v1/openapi.json`, so this package
+ * cannot silently diverge from the spec. That enforcement used to be a vitest
+ * suite, which the repository does not run -- the table shipped three
+ * operations short before #9687 replaced it with the runnable script, and
+ * #11894 deleted the suite.
+ *
+ * Differences from the retired app client (intentional):
+ *  - No `@/lib/api-contracts` import; the operation table is inlined so the
+ *    package has zero workspace coupling.
+ *  - Errors throw the typed subclass hierarchy in `errors.ts` (the app client
+ *    threw a single `OxinsiderApiError`).
+ *  - Extra typed convenience methods for list/candle/webhook-event/stream
+ *    surfaces and a typed `Grade` enum.
+ */
+import type { OperationBody, OperationData, OperationPath, OperationQuery, OperationResponse, ResponseMeta } from "./schema.js";
+/**
+ * The envelope `meta` as THIS client hands it to a caller: everything the
+ * contract declares (`ResponseMeta`), plus `etag`.
+ *
+ * `etag` is a client-side addition, not a contract field. The server sends it
+ * as an `ETag` response HEADER and never in the body, so the OpenAPI document
+ * is right not to declare it; this client lifts it into `meta` so a caller can
+ * echo it on a conditional re-request without reaching for the raw headers
+ * (#14278 -- the hand-written `ResponseMeta` carried `etag` inline, which read
+ * as though the server sent it).
+ */
+export type ClientResponseMeta = ResponseMeta & {
+    /** Lifted from the `ETag` response header by this client. */
+    etag?: string;
+    /**
+     * `true` when the response carried `X-Oxi-Sandbox: true`, which every
+     * response of the sandbox server does and no production response does.
+     * Lifted from the header by this client (#16138); absent otherwise.
+     */
+    sandbox?: true;
+    /**
+     * HTTP status of the success response, set by this client (#16137).
+     * `201` on `registerAgent`, `202` on a `submitTraderExport` that queued a
+     * new job, `200` everywhere else.
+     */
+    status?: number;
+    /** Unknown query names reported by the server in compatibility mode. */
+    queryIgnored?: string;
+    /** Normalized query names and values the server actually applied. */
+    effectiveQuery?: string;
+};
+export type ApiClientMethod = "GET" | "POST" | "PATCH" | "DELETE";
+/** Whether an operation requires the `oxi_sk_*` Bearer key. */
+export type AuthMode = "none" | "bearer";
+/**
+ * How an operation carries its success body, which decides the method that
+ * can read it (#16137). Before this, every row was assumed to answer the
+ * JSON envelope, so `call()` parsed Markdown as JSON and then rejected it as
+ * a bad 200.
+ *
+ *  - `envelope` (the default, and every row that omits `kind`): a JSON
+ *    `{ object, data, meta }` body -> `call()` and `list()`.
+ *  - `text`: a `text/*` body -> `text()`. The two `context.md` reads.
+ *  - `jsonrpc`: a JSON-RPC 2.0 response, or an empty `202` for a
+ *    notification -> `mcp()`. `POST /api/v1/mcp`.
+ *  - `sse`: an open-ended `text/event-stream` -> `streamFeed()` and the
+ *    other consumers in `stream.ts`. Buffering one with `call()` or `text()`
+ *    would never return, so both refuse it.
+ *
+ * `scripts/check-sdk-openapi-drift.mjs` derives the same kind from each
+ * operation's documented success media type and schema and fails on a row
+ * that disagrees, so a route that changes shape cannot keep a stale kind.
+ */
+export type ResponseKind = "envelope" | "text" | "jsonrpc" | "sse";
+export interface ApiClientOperation {
+    readonly method: ApiClientMethod;
+    readonly path: string;
+    readonly operationId: string;
+    readonly auth: AuthMode;
+    /** How the success body is carried; absent means `"envelope"`. */
+    readonly kind?: ResponseKind;
+}
+/**
+ * A published operation whose success is a REDIRECT, so it has no success
+ * body and cannot go through `call()` (#16137). Declared here rather than
+ * omitted in silence: the drift check requires every redirect-only spec
+ * operation to appear in `REDIRECT_OPERATIONS` with the method that follows
+ * it, so "the SDK cannot do this" is never the same as "nobody noticed".
+ */
+export interface ApiRedirectOperation {
+    readonly method: ApiClientMethod;
+    readonly path: string;
+    readonly operationId: string;
+    readonly auth: AuthMode;
+    /** The documented redirect status. */
+    readonly status: number;
+    /** How a caller reaches it through this package. */
+    readonly handledBy: string;
+}
+/** A published operation this client deliberately does not wrap. */
+export interface ApiUnsupportedOperation {
+    readonly method: ApiClientMethod;
+    readonly path: string;
+    readonly operationId: string;
+    /** Why there is no method, and what to use instead. */
+    readonly reason: string;
+}
+/**
+ * The full V1 operation table. One row per OpenAPI operation with a
+ * documented 2xx, which since #16137 includes the `201`-only
+ * `registerAgent`; `kind` says which method reads its body. Kept in lockstep
+ * with `web/public/api/v1/openapi.json` by
+ * `scripts/check-sdk-openapi-drift.mjs`, which also checks every row's kind
+ * against the spec. Do not add a row without a matching spec operation, and
+ * do not remove a spec operation without removing its row. A redirect-only
+ * operation belongs in `REDIRECT_OPERATIONS` below, not here.
+ */
+export declare const API_CLIENT_OPERATIONS: readonly [{
+    readonly method: "POST";
+    readonly path: "/api/v1/datasets/whale-trades";
+    readonly operationId: "submitWhaleDataset";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/datasets/whale-trades/{job_id}";
+    readonly operationId: "getWhaleDatasetStatus";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/datasets/whale-trades/{job_id}/cancel";
+    readonly operationId: "cancelWhaleDataset";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/me";
+    readonly operationId: "getAccountIdentity";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1";
+    readonly operationId: "getApiDiscovery";
+    readonly auth: "none";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}";
+    readonly operationId: "getTrader";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/traders/batch";
+    readonly operationId: "batchGetTraders";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/position-timeline";
+    readonly operationId: "getPositionTimeline";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/traders/{trader}/position-timeline";
+    readonly operationId: "getPositionTimelineById";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/positions";
+    readonly operationId: "listPositions";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/large-positions";
+    readonly operationId: "listLargePositions";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/pnl";
+    readonly operationId: "getTraderPnl";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/categories";
+    readonly operationId: "getTraderCategoryRecords";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/grade-at";
+    readonly operationId: "getTraderGradeAt";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/context";
+    readonly operationId: "getTraderContext";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/context.md";
+    readonly operationId: "getTraderContextMarkdown";
+    readonly auth: "bearer";
+    readonly kind: "text";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/trader/{address}/export";
+    readonly operationId: "submitTraderExport";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/export/status";
+    readonly operationId: "getTraderExportStatus";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/trader/{address}/export/cancel";
+    readonly operationId: "cancelTraderExport";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/leaderboard/trending";
+    readonly operationId: "listTrendingWallets";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/sports/pre-game-sides";
+    readonly operationId: "listPreGameSides";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/sports/pre-game-side-observations";
+    readonly operationId: "listPreGameSideObservations";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/sports-edge-signals";
+    readonly operationId: "listSportsEdgeSignals";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/sports-edge-observations";
+    readonly operationId: "listSportsEdgeObservations";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/games";
+    readonly operationId: "listGames";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/games/{event_slug}";
+    readonly operationId: "getGame";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/large-trades";
+    readonly operationId: "listLargeTrades";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/large-trades/history";
+    readonly operationId: "listLargeTradeHistory";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/large-trades/{id}/counterparties/executions";
+    readonly operationId: "listLargeTradeCounterpartyExecutions";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/large-trades/{id}/counterparties/executions/{execution_id}/makers";
+    readonly operationId: "listLargeTradeCounterpartyMakers";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/large-trades/{id}";
+    readonly operationId: "getLargeTrade";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/whale-trades";
+    readonly operationId: "listWhaleTrades";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/whale-trades/history";
+    readonly operationId: "listWhaleTradeHistory";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/whale-trades/{id}/counterparties/executions";
+    readonly operationId: "listWhaleTradeCounterpartyExecutions";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/whale-trades/{id}/counterparties/executions/{execution_id}/makers";
+    readonly operationId: "listWhaleTradeCounterpartyMakers";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/content/search";
+    readonly operationId: "searchContent";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/whale-trades/{id}";
+    readonly operationId: "getWhaleTrade";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/leaderboard";
+    readonly operationId: "listLeaderboard";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/markets/search";
+    readonly operationId: "searchMarkets";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/markets/explore";
+    readonly operationId: "exploreMarkets";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/markets/smart-money-flows";
+    readonly operationId: "listSmartMoneyFlows";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/markets/sharp-money-flows";
+    readonly operationId: "listSharpMoneyFlows";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/coverage";
+    readonly operationId: "getCoverage";
+    readonly auth: "none";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/platforms";
+    readonly operationId: "getPlatforms";
+    readonly auth: "none";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/market/{condition_id}/holders";
+    readonly operationId: "getMarketHolders";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/market/{condition_id}/flow";
+    readonly operationId: "getMarketFlow";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/market/{condition_id}/intel";
+    readonly operationId: "getMarketIntel";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/markets/flow/batch";
+    readonly operationId: "batchGetMarketFlow";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/markets/intel/batch";
+    readonly operationId: "batchGetMarketIntel";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/market/{condition_id}/snapshot";
+    readonly operationId: "getMarketSnapshot";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/market/{condition_id}/context.md";
+    readonly operationId: "getMarketContextMarkdown";
+    readonly auth: "bearer";
+    readonly kind: "text";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/market/{condition_id}/candles";
+    readonly operationId: "getMarketCandles";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/suspicious-trades";
+    readonly operationId: "listSuspiciousTrades";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/suspicious-trades/{id}";
+    readonly operationId: "getSuspiciousTrade";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/insider-radar";
+    readonly operationId: "listInsiderRadar";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/insider-radar/{id}";
+    readonly operationId: "getInsiderRadarFlag";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/events/feed/since";
+    readonly operationId: "getEventReplaySince";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/stream";
+    readonly operationId: "getStream";
+    readonly auth: "bearer";
+    readonly kind: "sse";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/webhooks";
+    readonly operationId: "listWebhooks";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/webhooks";
+    readonly operationId: "createWebhook";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/webhooks/{id}";
+    readonly operationId: "getWebhook";
+    readonly auth: "bearer";
+}, {
+    readonly method: "PATCH";
+    readonly path: "/api/v1/webhooks/{id}";
+    readonly operationId: "updateWebhook";
+    readonly auth: "bearer";
+}, {
+    readonly method: "DELETE";
+    readonly path: "/api/v1/webhooks/{id}";
+    readonly operationId: "deleteWebhook";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/webhooks/{id}/verify";
+    readonly operationId: "verifyWebhook";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/webhooks/{id}/rotate-secret";
+    readonly operationId: "rotateWebhookSecret";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/webhooks/{id}/rotate-secret/prepare";
+    readonly operationId: "prepareWebhookSecret";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/webhooks/{id}/rotate-secret/activate";
+    readonly operationId: "activateWebhookSecret";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/webhooks/{id}/rotate-secret/retire";
+    readonly operationId: "retireWebhookSecret";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/webhooks/events";
+    readonly operationId: "listWebhookEvents";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/webhooks/{id}/deliveries";
+    readonly operationId: "listWebhookDeliveries";
+    readonly auth: "bearer";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/webhooks/{id}/deliveries/{delivery_id}/redeliver";
+    readonly operationId: "redeliverWebhookDelivery";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/health";
+    readonly operationId: "getHealth";
+    readonly auth: "none";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/mcp";
+    readonly operationId: "createMcpJsonRpcResponse";
+    readonly auth: "bearer";
+    readonly kind: "jsonrpc";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/reports";
+    readonly operationId: "getReports";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/reports/daily";
+    readonly operationId: "getDailyReportSnapshot";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/reports/weekly";
+    readonly operationId: "getWeeklyReportSnapshot";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/reports/monthly";
+    readonly operationId: "getMonthlyReportSnapshot";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/export";
+    readonly operationId: "getTraderExportSnapshot";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/usage";
+    readonly operationId: "getUsage";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/pick-of-the-day";
+    readonly operationId: "getPickOfTheDay";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/pick-of-the-day/archive";
+    readonly operationId: "getPickOfTheDayArchive";
+    readonly auth: "bearer";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/pick-of-the-day/ledger";
+    readonly operationId: "getPickOfTheDayLedger";
+    readonly auth: "none";
+}, {
+    readonly method: "POST";
+    readonly path: "/api/v1/agents/register";
+    readonly operationId: "registerAgent";
+    readonly auth: "none";
+}];
+export type ApiOperationId = (typeof API_CLIENT_OPERATIONS)[number]["operationId"];
+/** Operations whose success body is a `text/*` document; read with `text()`. */
+export type TextOperationId = Extract<(typeof API_CLIENT_OPERATIONS)[number], {
+    kind: "text";
+}>["operationId"];
+/** Operations whose success body is JSON-RPC 2.0; read with `mcp()`. */
+export type JsonRpcOperationId = Extract<(typeof API_CLIENT_OPERATIONS)[number], {
+    kind: "jsonrpc";
+}>["operationId"];
+/** Operations whose success body is an open SSE stream; read through `stream.ts`. */
+export type SseOperationId = Extract<(typeof API_CLIENT_OPERATIONS)[number], {
+    kind: "sse";
+}>["operationId"];
+/**
+ * Published operations whose success is a redirect, with the method that
+ * follows it (#16137). These have no 2xx body, so they are absent from
+ * `API_CLIENT_OPERATIONS` and from the generated `schema.ts`;
+ * `scripts/check-sdk-openapi-drift.mjs` requires every redirect-only spec
+ * operation to be declared here, so one cannot go missing in silence again.
+ */
+export declare const REDIRECT_OPERATIONS: readonly [{
+    readonly method: "GET";
+    readonly path: "/api/v1/trader/{address}/export/download";
+    readonly operationId: "downloadTraderExport";
+    readonly auth: "bearer";
+    readonly status: 302;
+    readonly handledBy: "getTraderExportDownloadUrl() resolves the Location; downloadTraderExport() then fetches the object with no Authorization header.";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/datasets/whale-trades/{job_id}/download";
+    readonly operationId: "downloadWhaleDataset";
+    readonly auth: "bearer";
+    readonly status: 302;
+    readonly handledBy: "getWhaleDatasetDownloadUrl() resolves Location; fetch it without Authorization and verify the manifest hashes.";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/openapi.json";
+    readonly operationId: "redirectApiOpenapiSpec";
+    readonly auth: "none";
+    readonly status: 307;
+    readonly handledBy: "No method: the document is public and static, so fetch the URL directly and let your runtime follow the redirect. This package ships the same contract as generated types in schema.ts.";
+}];
+/**
+ * Published operations this client deliberately does not wrap, with the
+ * reason. The drift check requires every remaining spec operation to be
+ * accounted for here, so "unsupported" is always a stated decision.
+ */
+export declare const UNSUPPORTED_OPERATIONS: readonly [{
+    readonly method: "GET";
+    readonly path: "/api/v1/mcp";
+    readonly operationId: "openMcpEventStream";
+    readonly reason: "The MCP endpoint offers no server-to-client stream: GET answers 405 by design, so a client that reconnects to it would loop (#16354). Post JSON-RPC with mcp() instead.";
+}];
+/**
+ * The writes the API replays under `Idempotency-Key`: a second request with
+ * the same key and the same body returns the first result instead of
+ * repeating the write. Source of truth: the operations declaring the
+ * `Idempotency-Key` header parameter in `web/public/api/v1/openapi.json`,
+ * pinned by `scripts/check-sdk-openapi-drift.mjs` (#16182). Only these are
+ * retried on a transport or 5xx failure, and only when a key is set; a key on
+ * any other operation is refused before the request, since the server would
+ * ignore it and a retry could repeat the side effect (`verifyWebhook` sends
+ * a challenge to your URL each time; `submitTraderExport` starts a job).
+ */
+export declare const IDEMPOTENT_WRITE_OPERATIONS: readonly ["createWebhook", "updateWebhook", "deleteWebhook", "rotateWebhookSecret", "prepareWebhookSecret", "activateWebhookSecret", "retireWebhookSecret", "redeliverWebhookDelivery"];
+export type IdempotentWriteOperationId = (typeof IDEMPOTENT_WRITE_OPERATIONS)[number];
+/**
+ * POST operations that read and never write (#16182): the batch lookups.
+ * `POST /api/v1/traders/batch` and `POST /api/v1/markets/flow/batch` (with its
+ * deprecated alias `POST /api/v1/markets/intel/batch`) resolve
+ * their inputs and store nothing (`backend/src/api_v1/handlers/batch.rs`), so
+ * a repeat cannot duplicate a side effect. Each attempt is one request
+ * against the account's quota and one reservation of batch item units, which
+ * is exactly what a retried GET costs, so they are retried like a GET. Every
+ * other POST, PATCH or DELETE is retried only as a keyed write above.
+ */
+export declare const READ_ONLY_POST_OPERATIONS: readonly ["batchGetTraders", "batchGetMarketFlow", "batchGetMarketIntel"];
+/**
+ * Writes whose repeat converges on the state the first one reached, so a
+ * retry cannot repeat a side effect and needs no `Idempotency-Key` (#16254).
+ * `POST /api/v1/trader/{address}/export/cancel` moves a job at most once and
+ * answers its current state every time: a second cancel of a cancelled job
+ * returns it unchanged, and a cancel that lost the race to a finished file
+ * returns the ready job. They are retried like a read; the API does not read
+ * an `Idempotency-Key` on them, so one is refused like on any other write.
+ */
+export declare const CONVERGENT_WRITE_OPERATIONS: readonly ["cancelWhaleDataset", "cancelTraderExport"];
+/**
+ * How `call()` may repeat an operation that failed with 429, 502, 503, 504 or
+ * a network error before any response (#16182):
+ * - `"read"`: a GET, a read-only POST or a convergent write, repeated
+ *   without conditions.
+ * - `"keyed"`: an `IDEMPOTENT_WRITE_OPERATIONS` member, repeated only when
+ *   the request carries an `Idempotency-Key`, with the same key and the same
+ *   bytes on every attempt.
+ * - `"never"`: any other write; the first failure is thrown.
+ */
+export type RetryEligibility = "read" | "keyed" | "never";
+/** The retry class of an operation; see `RetryEligibility`. */
+export declare function retryEligibility(operation: Pick<ApiClientOperation, "method" | "operationId">): RetryEligibility;
+/**
+ * Trader skill grade. Source of truth:
+ * `components.schemas.Trader.properties.grade.enum` (S highest, F lowest).
+ */
+export declare const GRADES: readonly ["S", "A", "B", "C", "D", "F"];
+export type Grade = (typeof GRADES)[number];
+export type ApiQueryValue = string | number | boolean | null | undefined | readonly (string | number | boolean)[];
+export interface ApiRequestOptions {
+    path?: Record<string, string | number>;
+    query?: Record<string, ApiQueryValue>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    /** Reject query names the operation does not publish before it runs. */
+    strictQuery?: boolean;
+    /** Cooperative cancellation; composed with the request deadline. */
+    signal?: AbortSignal;
+    /**
+     * Per-call deadline in ms, overriding the client default; `null` disables
+     * it for this call. The SSE stream (`streamFeed`) never has one. Retries
+     * share this one deadline: no retry is started that cannot finish inside it.
+     */
+    timeoutMs?: number | null;
+    /**
+     * Retries for this call, overriding the client's `maxRetries` (#14281).
+     * `0` sends exactly one request, which is the SDK's behaviour before retries.
+     */
+    maxRetries?: number;
+    /**
+     * Sent as the `Idempotency-Key` header. Accepted only on the
+     * `IDEMPOTENT_WRITE_OPERATIONS` (`createWebhook`, `updateWebhook`,
+     * `deleteWebhook`, `rotateWebhookSecret`, `prepareWebhookSecret`,
+     * `activateWebhookSecret`, `retireWebhookSecret`, `redeliverWebhookDelivery`),
+     * where a replay with the same key and body returns the first result
+     * instead of repeating the write; on any other operation `call()` throws
+     * before sending, since the server would ignore the key (#16182). A keyed
+     * write is the only non-read request the SDK retries, always with the
+     * same key and the same body bytes. On `IdempotencyInProgressError`, or
+     * when the outcome is unknown after a timeout or exhausted retries, send
+     * the SAME key and body again to learn what happened; never mint a new key
+     * for the same intent.
+     * The effective header, after this option overrides `headers`, must be
+     * nonempty after trimming and at most 255 UTF-8 bytes. Invalid keys throw
+     * before fetch, even with `maxRetries: 0`; omit the key for one attempt.
+     */
+    idempotencyKey?: string;
+}
+export interface ApiClientOptions {
+    /**
+     * The server URL, one of the `servers` in the OpenAPI document:
+     * `https://api.0xinsider.com` (the default) or
+     * `https://0xinsider.com/sandbox`. A path on it is kept, so every operation
+     * path (`/api/v1/...`) is appended after it (#16138: the path used to be
+     * discarded, which sent a sandbox client to the live host). Trailing slashes
+     * are trimmed, and a trailing `/api/v1` is removed once, since the operation
+     * paths carry it.
+     */
+    baseUrl?: string;
+    /**
+     * The `oxi_sk_live_*` secret API key, or a sandbox key (`oxi_sk_test_*`)
+     * when `sandbox` is set.
+     */
+    apiKey?: string;
+    /**
+     * Explicit sandbox mode (#16138). `baseUrl` defaults to
+     * `SANDBOX_BASE_URL` (`https://0xinsider.com/sandbox`), every operation is
+     * allowed without a key, since the sandbox needs no credential, and a live
+     * key (`oxi_sk_live_*`) is refused by the constructor so it is never sent
+     * there. A sandbox key from `POST /api/v1/agents/register` is optional and
+     * is sent when given. `OxinsiderApiClient.sandbox()` builds one.
+     */
+    sandbox?: boolean;
+    /** Override the global `fetch` (e.g. for testing or a proxy agent). */
+    fetch?: typeof fetch;
+    /**
+     * Deadline for every request, connect to body, in ms. Default
+     * `DEFAULT_TIMEOUT_MS` (15 000); `null` disables it. A request that misses
+     * it rejects with `RequestTimeoutError`. Long-lived reads (`streamFeed`)
+     * are not subject to it (#11115).
+     */
+    timeoutMs?: number | null;
+    /**
+     * How many times a failed idempotent request is retried (#14281). Default
+     * `DEFAULT_MAX_RETRIES` (2); `0` disables retries.
+     *
+     * Retried: a GET, a read-only POST (`READ_ONLY_POST_OPERATIONS`), or an
+     * `IDEMPOTENT_WRITE_OPERATIONS` write carrying an `Idempotency-Key`, that
+     * failed with 408, 429, 502, 503, 504, or a network error before any
+     * response (`retryEligibility`, #16182). A 408 is the server's own timeout
+     * (`request_timeout`, #16146): it carries `Retry-After` on a GET, and a
+     * keyed write replays safely. The wait is the
+     * response's `Retry-After` (delta-seconds or an HTTP-date, `parseRetryAfter`)
+     * plus up to 250 ms of jitter when present, otherwise a jittered exponential
+     * backoff from 500 ms capped at 8 s. A `Retry-After` longer than
+     * `RETRY_AFTER_CEILING_MS` (60 s) is not waited out; the error is thrown so
+     * the caller can schedule it from `retryAfterSeconds` or `retryAt`. Never retried: 400, 401, 402, 403, 404, 409, 500, a write
+     * without a key, this client's own timeout, or a caller abort. A retry never starts unless it
+     * can finish inside `timeoutMs`, and a caller `AbortSignal` ends a backoff at
+     * once.
+     */
+    maxRetries?: number;
+}
+/** Default production API base used when `baseUrl` is omitted. */
+export declare const DEFAULT_BASE_URL = "https://api.0xinsider.com";
+/**
+ * The sandbox server, the second `servers` entry of the OpenAPI document: no
+ * credential, no production data, every documented operation answered with
+ * its example or a deterministic sample, `?sandbox_status=<code>` for a
+ * documented error, and `X-Oxi-Sandbox: true` on every response. The two
+ * Markdown documents answer `200 text/markdown` there and the export download
+ * answers its `302` to a sample file the sandbox serves itself. `GET
+ * /api/v1/stream` is the one operation it does not simulate and answers 400,
+ * because an SSE stream is a live connection rather than a body.
+ */
+export declare const SANDBOX_BASE_URL = "https://0xinsider.com/sandbox";
+/** Default per-request deadline; see `ApiClientOptions.timeoutMs`. */
+export declare const DEFAULT_TIMEOUT_MS = 15000;
+/** Default retry budget; see `ApiClientOptions.maxRetries`. */
+export declare const DEFAULT_MAX_RETRIES = 2;
+/**
+ * The API key travels as a bearer header on every request, so the base URL
+ * decides who receives it. Only `https:` is accepted, with `http:` allowed for
+ * a loopback host (a local backend on `localhost` or `127.0.0.1`). Anything
+ * else throws from the constructor, before any request is sent (#11115).
+ */
+export declare function assertTrustedBaseUrl(baseUrl: string): URL;
+/**
+ * Join an `/api/v1/...` path onto the server URL, keeping the server's own
+ * path (`/sandbox`) exactly once. REST (`buildUrl`) and the SSE stream
+ * (`stream.ts`) both resolve through this, so the two cannot disagree about
+ * where a path-bearing base points (#16138: `new URL("/api/v1/...", base)`
+ * resolved against the origin and dropped `/sandbox`).
+ */
+export declare function resolveApiUrl(baseUrl: string, path: string): URL;
+/**
+ * One signal that aborts on the deadline OR when the caller's signal aborts.
+ * Uses native composition where available. The manual fallback removes both
+ * source listeners when either source aborts.
+ */
+export declare function composeSignals(timeoutMs: number | null, caller?: AbortSignal): AbortSignal | undefined;
+/** Standard single-resource envelope: `{ object, data, meta }`. */
+export interface ApiEnvelope<T> {
+    object: string;
+    data: T;
+    meta?: ClientResponseMeta;
+}
+/** Stripe-style list envelope: `{ object: "list", data, has_more, next_cursor, total?, meta }`. */
+export interface ApiListEnvelope<T> {
+    object: "list";
+    data: T[];
+    has_more: boolean;
+    next_cursor?: string | null;
+    total?: number | null;
+    meta?: ClientResponseMeta;
+    /**
+     * When this body was computed, on endpoints that publish a freshness envelope
+     * (`markets/explore` today). Absent elsewhere.
+     *
+     * Pair it with `fresh_for_seconds` to bound how long you reuse the body:
+     * `fresh_for_seconds - age(computed_at)`. The remainder is deliberately not
+     * pre-subtracted, because a cached body cannot carry a number that changes
+     * while it sits in a cache. Both are excluded from the `ETag` validator, so a
+     * body recomputed with identical data keeps its validator.
+     */
+    computed_at?: string;
+    /** How long the body computed at `computed_at` is good for, in seconds. */
+    fresh_for_seconds?: number;
+}
+export type CategorySkillStatus = "live" | "insufficient" | "stale" | "unknown" | "degraded";
+export interface CategorySkillStatusCounts {
+    live: number;
+    insufficient: number;
+    stale: number;
+    unknown: number;
+    degraded: number;
+}
+/** Query parameters accepted by {@link OxinsiderApiClient.listGames}. */
+export type GamesListParams = OperationQuery["listGames"];
+/** One game: both sides, its schedule, its provider status and its markets. */
+export type { Game } from "./schema.js";
+/** Query parameters of `GET /api/v1/sports/pre-game-sides` (#16310). */
+export type PreGameSidesParams = OperationQuery["listPreGameSides"];
+/** @deprecated Use {@link PreGameSidesParams} (#16310). */
+export type SportsEdgeSignalsParams = PreGameSidesParams;
+/** Observation cohorts exposed by `listPreGameSideObservations`. */
+export type SportsEdgeObservationCohort = "wider_holder" | "in_play" | "emerging_pile";
+/** Source of the provider holder snapshot used to build an observation. */
+export type SportsEdgeObservationProviderSource = "cached" | "live";
+/** Why a sport's upcoming-board source is (un)available in the funnel report. */
+export type SportsEdgeObservationBoardUpcomingStatus = "unknown" | "not_configured" | "available" | "capacity_limited" | "source_unavailable" | "cold_unavailable" | "deadline_unavailable";
+/** Scope attribution for an unavailable upcoming-board union. */
+export type SportsEdgeObservationBoardUnavailableScope = "category" | "nfl" | "cfb" | "nba" | "wnba" | "nhl" | "mls" | "valorant" | "league-of-legends" | "counter-strike-2" | "dota-2" | "registry" | "union" | "wave";
+/** Truthful state of the cross-market directional read. */
+export type SportsEdgeObservationDirectionalStatus = "available" | "unknown_ungrouped" | "unknown_stale" | "unavailable";
+/**
+ * Provider binary-column selector for observation markets: 0 selects
+ * outcome_yes/token_id_yes; 1 selects outcome_no/token_id_no. Use piled_side,
+ * not this index, for participant identity.
+ */
+export type SportsEdgeObservationOutcomeIndex = 0 | 1;
+/** Closed grade vocabulary for the best holder grade on an observation. */
+export type SportsEdgeObservationTopGrade = "S" | "A" | "B";
+/** Canonical sports emitted by observation responses. */
+export type SportsEdgeObservationSport = "Basketball" | "Football" | "Baseball" | "Hockey" | "MMA" | "Boxing" | "Soccer" | "Cricket" | "Golf" | "Tennis" | "Esports" | "Racing" | "Table Tennis" | "Pickleball";
+/**
+ * Full list response, including the observation snapshot and accountable
+ * funnel: the operation's own envelope (#16136). `degraded` is the
+ * snapshot-wide verdict; fully accounted `capacity_limited` rows alone do
+ * not set it.
+ */
+export type PreGameSideObservationsResponse = OperationEnvelope<"listPreGameSideObservations">;
+/** @deprecated Use {@link PreGameSideObservationsResponse} (#16310). */
+export type SportsEdgeObservationsResponse = PreGameSideObservationsResponse;
+/** Query parameters of `GET /api/v1/sports/pre-game-side-observations` (#16310). */
+export type PreGameSideObservationsParams = OperationQuery["listPreGameSideObservations"];
+/** @deprecated Use {@link PreGameSideObservationsParams} (#16310). */
+export type SportsEdgeObservationsParams = PreGameSideObservationsParams;
+/**
+ * One qualifying category expert on a Pick of the Day's backed side.
+ *
+ * Every threshold below holds BY CONSTRUCTION -- the selector only ever freezes a wallet that
+ * cleared all of them -- so a consumer can render the numbers without re-checking them.
+ */
+export interface PickQualifyingExpert {
+    /** Policy 6 admission exception; absent on earlier frozen policies. */
+    lane?: "standard" | "longshot_specialist";
+    /** Answered, index-scoped provider probability, present only on specialist lanes. */
+    lane_probability?: number;
+    lane_probability_source?: "p";
+    address: string;
+    name?: string | null;
+    /** Public V1 exposes `S` or `A`; internal policy v2 also admits B. */
+    grade?: string | null;
+    /**
+     * The canonical sport BUCKET the rate below was measured over (for example `Basketball`).
+     *
+     * Label `win_rate` with THIS field, never with the pick's `display_category`: that names an
+     * exact league (NBA/WNBA/NFL/NHL/MLB/UFC) which folds into a broader bucket, so rendering
+     * "68% of their NBA markets" for a Basketball-wide rate publishes a false quantified claim.
+     */
+    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. Scale x100 at the display edge. `null` for an
+     * expert who qualified on the category-skill v2 definition only (`source` = `v2`).
+     */
+    win_rate: number | null;
+    /** Resolved markets in `canonical_category` behind `win_rate`. At least 10. `null` with it. */
+    n_resolved: number | null;
+    /**
+     * Which definition qualified the wallet: `v1` (the profitability rate above) or `v2` (the
+     * forward-only category-skill calibration edge below). 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 = 8 points). Positive by construction for
+     * a `v2` expert; present on a `v1` expert only when the wallet also has 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. Clears the v2 sample floor for a `v2`
+     * expert; the floor is the selector's and is not published.
+     */
+    independent_event_count?: number | null;
+    /**
+     * Polymarket's own `currentValue` for this wallet on the backed outcome, in USD, as of
+     * selection. Clears the lane's net-position floor at selection; the floor is the selector's,
+     * has changed between gate policies, and is not published.
+     */
+    position_usd: number;
+    /**
+     * The same wallet's `currentValue` on the OTHER outcome of this market, in USD, as of
+     * selection. From gate policy v5 the floor is read on the net: `position_usd` minus this
+     * value clears the lane's floor, so 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.
+     */
+    opposite_position_usd?: number | null;
+    /**
+     * When the skill read model behind the evidence was last rebuilt: `trader_category_stats`
+     * for a `source: v1` expert, `category_skill_v2_current.as_of` for a `source: v2` expert.
+     */
+    stats_computed_at: string;
+}
+/**
+ * Tennis tour a competitor belongs to. 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.
+ */
+export type TennisTour = "atp" | "wta" | "itf";
+/**
+ * The daily editorial Pick of the Day. Single-object envelope for
+ * `getPickOfTheDay` (`GET /api/v1/pick-of-the-day`). Field names mirror the
+ * JSON wire shape (snake_case); the backend omits null/absent optional fields.
+ * The outer object retains the historical first-pick fields and `picks` carries
+ * the ordered daily picks, normally three to ten items and never more than ten.
+ * A published pick whose holder proof is not readable yet is listed in
+ * `proof_pending_picks` instead of `picks` (#10698).
+ */
+/** Typed 304 result returned for a matching `If-None-Match` conditional GET. */
+export interface ApiNotModifiedResponse {
+    object: "not_modified";
+    data: null;
+    meta: {
+        status: 304;
+        etag?: string;
+        request_id?: string;
+        queryIgnored?: string;
+        effectiveQuery?: string;
+        [key: string]: unknown;
+    };
+}
+export type ApiClientResponse<T> = ApiEnvelope<T> | ApiNotModifiedResponse;
+/** `etag`, `sandbox` and `status`, lifted by this client onto whichever `meta` the operation declares. */
+export type ClientMeta<M> = M & {
+    /** Lifted from the `ETag` response header by this client. */
+    etag?: string;
+    /** `true` when the response carried `X-Oxi-Sandbox: true` (#16138). */
+    sandbox?: true;
+    /**
+     * The HTTP status of the success response, set by this client (#16137).
+     *
+     * Not every operation answers `200`, and the difference is the answer:
+     * `registerAgent` answers `201`, and `submitTraderExport` answers `202`
+     * when it queued a new job and `200` when it returned one that already
+     * existed. The envelope body is the same shape either way, so without this
+     * a caller could not tell a fresh job from a replayed one.
+     */
+    status?: number;
+};
+/** Operations whose 200 is the JSON envelope (`object`, `data`, `meta`); the two text bodies and the JSON-RPC post are not. */
+export type EnvelopeOperationId = {
+    [K in ApiOperationId]: OperationResponse[K] extends {
+        object: string;
+        data: unknown;
+        meta: unknown;
+    } ? K : never;
+}[ApiOperationId];
+/** Envelope operations that page: `data` is an array and `has_more` is declared. */
+export type ListOperationId = {
+    [K in EnvelopeOperationId]: OperationResponse[K] extends {
+        has_more: boolean;
+        data: readonly unknown[];
+    } ? K : never;
+}[EnvelopeOperationId];
+/** The operation's documented `meta` type. */
+export type OperationMeta<K extends ApiOperationId> = OperationResponse[K] extends {
+    meta: infer M;
+} ? M : never;
+/**
+ * What a 200 resolves to: the operation's own envelope (`object` literal,
+ * `data`, every top-level field such as `has_more` or a list's `totals`) with
+ * its own `meta` type (`BatchResponseMeta` on a batch, `EventReplayMeta` on
+ * the replay, `ResponseMeta` elsewhere) plus this client's lifted `etag` and
+ * `sandbox`.
+ */
+export type OperationEnvelope<K extends EnvelopeOperationId> = Omit<OperationResponse[K], "meta"> & {
+    meta: ClientMeta<OperationMeta<K>>;
+};
+/** A `call()` result: the envelope, or the typed 304 when `If-None-Match` matched. */
+export type OperationResult<K extends EnvelopeOperationId> = OperationEnvelope<K> | ApiNotModifiedResponse;
+/** One item of a list operation's `data`. */
+export type OperationItem<K extends ListOperationId> = OperationData[K] extends readonly (infer I)[] ? I : never;
+/**
+ * `call()` options bound to one operation: `path` is required exactly when
+ * the route has path parameters, `query` is the documented query, `body` is
+ * required exactly when the operation declares a request body, and the
+ * transport options (`signal`, `timeoutMs`, `maxRetries`, `headers`,
+ * `idempotencyKey`) are the shared ones.
+ */
+export type OperationRequestOptions<K extends ApiOperationId> = Omit<ApiRequestOptions, "path" | "query" | "body"> & (OperationPath[K] extends Record<string, never> ? {
+    path?: OperationPath[K];
+} : {
+    path: OperationPath[K];
+}) & {
+    query?: OperationQuery[K];
+} & ([
+    OperationBody[K]
+] extends [never] ? {
+    body?: never;
+} : {
+    body: OperationBody[K];
+});
+/**
+ * Whether operation `K` cannot be called without options: it has path
+ * parameters or a request body (#16643). For a union of operations it is
+ * `true` when any member needs them.
+ */
+export type OperationRequiresOptions<K extends ApiOperationId> = true extends (K extends ApiOperationId ? OperationPath[K] extends Record<string, never> ? [OperationBody[K]] extends [never] ? false : true : true : never) ? true : false;
+/** The operations that can be called with no options at all. */
+export type OptionalInputOperationId = {
+    [K in ApiOperationId]: OperationRequiresOptions<K> extends true ? never : K;
+}[ApiOperationId];
+/**
+ * The options argument of a typed overload (#16643): required when the
+ * operation has path parameters or a body, optional otherwise, so
+ * `client.call("createWebhook")` and `client.list("listWebhookDeliveries")`
+ * fail to compile instead of failing at the API.
+ */
+export type OperationOptionsArgs<K extends ApiOperationId, O> = OperationRequiresOptions<K> extends true ? [options: O] : [options?: O];
+/**
+ * The operation id a LOOSE overload accepts (#16643). A value typed as the
+ * whole `ApiOperationId` union (an id chosen at runtime) passes; a literal
+ * passes only when the operation needs no options, so a literal with a
+ * mandatory path or body cannot fall through to the loose form without them.
+ * A caller that names the result type explicitly (`call<T>(...)`) skips the
+ * inference this relies on; the runtime still refuses a missing path
+ * parameter before any request.
+ */
+export type RuntimeOperationId<I extends ApiOperationId> = I & (ApiOperationId extends I ? unknown : OptionalInputOperationId);
+/** The transport options a convenience method forwards: everything but the parts it fills itself. */
+export type ConvenienceOptions = Omit<ApiRequestOptions, "path" | "query" | "body">;
+/** The MCP methods `POST /api/v1/mcp` accepts, from the operation's request body. */
+export declare const MCP_METHODS: readonly ["initialize", "notifications/initialized", "notifications/cancelled", "ping", "tools/list", "tools/call"];
+export type McpMethod = (typeof MCP_METHODS)[number];
+/**
+ * One JSON-RPC 2.0 message for `POST /api/v1/mcp`. `jsonrpc` defaults to
+ * `"2.0"`. Omit `id` for a notification, which answers an empty `202`.
+ */
+export interface McpJsonRpcRequest {
+    jsonrpc?: "2.0";
+    /** Echoed exactly in the response. Omit it on a notification. */
+    id?: string | number | null;
+    method: McpMethod;
+    params?: Record<string, unknown>;
+}
+/** The JSON-RPC 2.0 response body, as the operation declares it. */
+export type McpJsonRpcResponse = OperationResponse["createMcpJsonRpcResponse"];
+/** Options for `mcp()`: the shared transport options plus the two MCP headers. */
+export interface McpOptions extends ConvenienceOptions {
+    /** Sent as `Mcp-Session-Id`; use the value a previous response returned. */
+    sessionId?: string;
+    /**
+     * Sent as `MCP-Protocol-Version`. Omit it and the server serves
+     * `2025-03-26`; an unsupported revision is a `400`.
+     */
+    protocolVersion?: string;
+}
+/** What `mcp()` returns: the JSON-RPC response, or the accepted notification. */
+export interface McpResult {
+    /** `200` for a JSON-RPC response, `202` for an accepted notification. */
+    status: 200 | 202;
+    /** The JSON-RPC body, or `null` for the empty `202` a notification receives. */
+    response: McpJsonRpcResponse | null;
+    /** `Mcp-Session-Id`, when the server issued or echoed one. */
+    sessionId?: string;
+}
+/** Where a finished export actually lives, from the `302`'s `Location`. */
+export interface TraderExportDownloadTarget {
+    /**
+     * The presigned object URL. It authorizes itself, so treat it as a
+     * credential: never log it and never share it.
+     */
+    url: string;
+    /**
+     * When the link stops working, read from the URL's own SigV4
+     * `X-Amz-Date` and `X-Amz-Expires`. Absent when the URL does not carry
+     * them. Links last at most one hour and cannot outlive artifact retention.
+     */
+    expiresAt?: string;
+}
+/** The manifest field used by `downloadTraderExport` when verification is enabled. */
+export interface TraderExportDownloadIntegrity {
+    algorithm: "sha256";
+    expectedSha256: string;
+    expectedSizeBytes: number;
+}
+/** The object response, with what its headers said about the file. */
+export interface TraderExportDownload extends TraderExportDownloadTarget {
+    /** Not buffered: read `response.body` as a stream. */
+    response: Response;
+    /** `Content-Length` of the object, or `null` when the store sent none. */
+    contentLength: number | null;
+    contentType: string | null;
+    /** The filename from `Content-Disposition`, or `null`. */
+    filename: string | null;
+    /** The expected content checksum, or `null` when `verifyChecksum` was not requested. */
+    integrity: TraderExportDownloadIntegrity | null;
+}
+export interface TraderExportDownloadOptions extends ConvenienceOptions {
+    /**
+     * A deadline in ms for the OBJECT fetch, which has none by default: an
+     * export can be far larger than a REST read and the 15-second default
+     * would cut it off mid-file. `timeoutMs` still bounds the redirect.
+     */
+    downloadTimeoutMs?: number | null;
+    /** Fetch the owner-authorized manifest and verify the streamed content before it is consumed. */
+    verifyChecksum?: boolean;
+}
+/** Shared paging params accepted by Stripe-style list endpoints. */
+export interface ListParams {
+    limit?: number;
+    cursor?: string;
+    [key: string]: ApiQueryValue;
+}
+/** `GET /api/v1/leaderboard` -> parameters -> strategy (`web/public/api/v1/openapi.json`). */
+export declare const LEADERBOARD_STRATEGIES: readonly ["accumulator", "algo_trader", "arbitrageur", "directional", "event_driven", "market_maker", "momentum", "scalper", "speculator", "swing_trader"];
+export type LeaderboardStrategy = (typeof LEADERBOARD_STRATEGIES)[number];
+/**
+ * Query parameters for `GET /api/v1/leaderboard`, from the operation
+ * (#16136). The board has no `min_grade`: it only holds S, A, and B traders,
+ * and the backend drops an unknown query key instead of rejecting it
+ * (#10642), which is why the type now refuses one.
+ */
+export type LeaderboardListParams = OperationQuery["listLeaderboard"];
+/** Query parameters for `GET /api/v1/leaderboard/trending`. */
+export type TrendingWalletsParams = OperationQuery["listTrendingWallets"];
+/** Query parameters of the V1 large-trade list (#16304). */
+export type LargeTradeListParams = OperationQuery["listLargeTrades"];
+/** Query parameters of the V1 historical large-trade replay (#16304). */
+export type LargeTradeHistoryParams = OperationQuery["listLargeTradeHistory"];
+/** @deprecated Use {@link LargeTradeListParams} (#16304). */
+export type WhaleTradeListParams = OperationQuery["listWhaleTrades"];
+/** @deprecated Use {@link LargeTradeHistoryParams} (#16304). */
+export type WhaleTradeHistoryParams = OperationQuery["listWhaleTradeHistory"];
+/** Query parameters of `GET /api/v1/positions`. */
+export type PositionsListParams = OperationQuery["listPositions"];
+/** Query parameters of `GET /api/v1/large-positions`. */
+export type LargePositionsListParams = OperationQuery["listLargePositions"];
+/** Query parameters of the sharp-money flows read and its legacy alias. */
+export type SharpMoneyFlowsParams = OperationQuery["listSharpMoneyFlows"];
+/** Query parameters of `GET /api/v1/suspicious-trades`: `min_suspicion` and `severity`, not a grade. */
+export type SuspiciousTradesListParams = OperationQuery["listSuspiciousTrades"];
+/**
+ * @deprecated Use `SuspiciousTradesListParams`; the Insider Radar spelling of
+ * this contract was renamed to suspicious trades in #16301. The deprecated
+ * `GET /api/v1/insider-radar` takes the same parameters, so this stays an
+ * alias with no retirement date.
+ */
+export type InsiderRadarListParams = SuspiciousTradesListParams;
+/** Query parameters of `GET /api/v1/markets/explore`. */
+export type ExploreMarketsParams = OperationQuery["exploreMarkets"];
+/**
+ * Body-level `expand` values of `POST /api/v1/traders/batch`. The type is the
+ * operation's own body (`OperationBody["batchGetTraders"]["expand"]`); the
+ * const is the same list as a runtime value for a caller that iterates it.
+ */
+export declare const BATCH_TRADER_EXPANSIONS: readonly ["strategy", "categories", "quant_metrics", "trust"];
+export type BatchTraderExpand = NonNullable<OperationBody["batchGetTraders"]["expand"]>[number];
+/**
+ * Options for `batchGetTraders`. The body is built from the positional
+ * `traders` array and `expand`, so `body` is not accepted here.
+ */
+export interface BatchGetTradersOptions extends ConvenienceOptions {
+    /** Shared expand flags applied to every trader item; sent as the body's `expand`. */
+    expand?: OperationBody["batchGetTraders"]["expand"];
+}
+export declare class OxinsiderApiClient {
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly sandbox;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    /**
+     * A client for the sandbox server (#16138): `SANDBOX_BASE_URL`, no
+     * credential needed, example data only, never production data. The same
+     * as `new OxinsiderApiClient({ ...options, sandbox: true })`; pass a
+     * sandbox key (`oxi_sk_test_*`) as `apiKey` to have it checked.
+     *
+     * @example
+     * const sandbox = OxinsiderApiClient.sandbox();
+     * const board = await sandbox.listLeaderboard({ limit: 5 }); // no key
+     * board.meta?.sandbox; // true
+     */
+    static sandbox(options?: Omit<ApiClientOptions, "sandbox">): OxinsiderApiClient;
+    constructor(options?: ApiClientOptions);
+    /**
+     * Execute an envelope operation by id. Throws the matching
+     * `OxinsiderApiError` subclass on a non-2xx response, returns a typed
+     * `not_modified` result for a 304, and otherwise returns the operation's
+     * own `{ object, data, meta, ... }` envelope (#16136): `path` is required
+     * exactly when the route has path parameters, `query` and `body` are the
+     * documented ones, and `data` and `meta` are the operation's types.
+     *
+     * @example
+     * const trader = await client.call("getTrader", { path: { address } });
+     * if (trader.object === "trader") trader.data.grade; // typed
+     */
+    call<K extends EnvelopeOperationId>(operationId: K, ...options: OperationOptionsArgs<K, OperationRequestOptions<K>>): Promise<OperationResult<K>>;
+    /**
+     * The untyped form, for an operation chosen at runtime or a caller that
+     * asserts the shape itself with `T`: loose `path`, `query` and `body`, and
+     * the generic `{ object, data, meta? }` envelope back. Every convenience
+     * method uses the typed form above; reach for this one only when the
+     * operation id is not a literal.
+     */
+    call<T = unknown, I extends ApiOperationId = ApiOperationId>(operationId: RuntimeOperationId<I>, options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    /**
+     * Read a `text/*` operation's body as a string (#16137).
+     *
+     * `getTraderContextMarkdown` and `getMarketContextMarkdown` answer
+     * `text/markdown`, which `call()` used to parse as JSON and then reject as
+     * an invalid 200. Authentication, the request deadline, retries and the
+     * typed error hierarchy are the same as `call()`; only the body differs.
+     *
+     * @example
+     * const md = await client.text("getTraderContextMarkdown", { path: { address } });
+     */
+    text<K extends TextOperationId>(operationId: K, ...options: OperationOptionsArgs<K, OperationRequestOptions<K>>): Promise<string>;
+    /** The untyped form, for an operation id chosen at runtime. */
+    text<I extends ApiOperationId = ApiOperationId>(operationId: RuntimeOperationId<I>, options?: ApiRequestOptions): Promise<string>;
+    /**
+     * Post one MCP JSON-RPC 2.0 message to `POST /api/v1/mcp` (#16137).
+     *
+     * The endpoint answers a JSON-RPC envelope, not the `{ object, data, meta }`
+     * envelope every other operation uses, so `call()` refuses it. A request
+     * (one carrying `id`) comes back as `status: 200` with `response` set; a
+     * supported notification (no `id`) comes back as `status: 202` with
+     * `response: null`, which is the empty body the server sends. A JSON-RPC
+     * `error` member is a protocol-level failure and is RETURNED, not thrown:
+     * only a non-2xx HTTP status throws, because an unknown tool is an answer
+     * and a revoked credential is not.
+     *
+     * The request is never retried: `tools/call` can have an effect, and the
+     * endpoint honours no `Idempotency-Key`.
+     *
+     * @example
+     * const listed = await client.mcp({ method: "tools/list", id: 1 });
+     * listed.response?.result;
+     */
+    mcp(request: McpJsonRpcRequest, options?: McpOptions): Promise<McpResult>;
+    /**
+     * Read the owner-authorized lifecycle and artifact manifest for one export
+     * job. The manifest is immutable for the artifact; the download URL remains
+     * temporary and is resolved separately.
+     */
+    /** Submit a bounded cross-market snapshot; repeated identical live requests reuse it. */
+    submitWhaleDataset(body: OperationBody["submitWhaleDataset"], options?: ConvenienceOptions): Promise<OperationResult<"submitWhaleDataset">>;
+    getWhaleDatasetStatus(jobId: number, options?: ConvenienceOptions): Promise<OperationResult<"getWhaleDatasetStatus">>;
+    cancelWhaleDataset(jobId: number, options?: ConvenienceOptions): Promise<OperationResult<"cancelWhaleDataset">>;
+    /** Resolve only the signed URL. Never log it or forward API credentials to storage. */
+    getWhaleDatasetDownloadUrl(jobId: number, options?: ConvenienceOptions): Promise<TraderExportDownloadTarget>;
+    /** Stream decoded NDJSON, validating its manifest hash when the body finishes. */
+    downloadWhaleDataset(jobId: number, options?: TraderExportDownloadOptions): Promise<TraderExportDownload>;
+    getTraderExportStatus(address: OperationPath["getTraderExportStatus"]["address"], jobId: OperationQuery["getTraderExportStatus"]["job_id"], options?: ConvenienceOptions): Promise<OperationResult<"getTraderExportStatus">>;
+    /**
+     * Resolve the presigned object URL behind `GET /api/v1/trader/{address}/export/download`
+     * without downloading anything (#16137).
+     *
+     * The route answers `302` with a `Location`, which `call()` treats as an
+     * error. This reads the redirect target and stops there, so a caller can
+     * hand the URL to a download manager or a browser. The returned URL is a
+     * bearer credential in itself: anyone holding it can read the file until it
+     * expires, so do not log it.
+     *
+     * Browser caveat: `fetch` with `redirect: "manual"` yields an opaque
+     * redirect whose `Location` no script can read. The method says so rather
+     * than guessing a URL; run the download from a server runtime.
+     */
+    getTraderExportDownloadUrl(address: OperationPath["getTraderExportStatus"]["address"], jobId: OperationQuery["getTraderExportStatus"]["job_id"], options?: ConvenienceOptions): Promise<TraderExportDownloadTarget>;
+    /**
+     * Download a finished export (#16137): resolve the `302`, then fetch the
+     * object store directly.
+     *
+     * The second request carries NO headers at all, so the live API key never
+     * reaches the object store; the presigned URL is its own credential. The
+     * body is not buffered -- read `response.body` as a stream and write it
+     * where it belongs.
+     *
+     * There is no default deadline on the object fetch, the way `streamFeed`
+     * has none: a multi-gigabyte export would fail the 15-second REST default
+     * halfway through. Pass `signal` to cancel it, or `downloadTimeoutMs` for
+     * a deadline of your own. `timeoutMs` still bounds the redirect request.
+     *
+     * @example
+     * const { response, filename } = await client.downloadTraderExport(address, jobId);
+     * await pipeline(Readable.fromWeb(response.body), createWriteStream(filename ?? "export.json"));
+     */
+    downloadTraderExport(address: OperationPath["getTraderExportStatus"]["address"], jobId: OperationQuery["getTraderExportStatus"]["job_id"], options?: TraderExportDownloadOptions): Promise<TraderExportDownload>;
+    private downloadExportObject;
+    /**
+     * Look up an operation and refuse it when the caller reached for the wrong
+     * reader (#16137): `call()` on a Markdown route used to fail as a bad 200.
+     */
+    private resolveOperation;
+    /**
+     * One request pipeline for every transport: URL and headers, the retry
+     * policy, one deadline shared by every attempt, the typed error hierarchy,
+     * and cancellation held live through body consumption. `consume` runs
+     * inside that window, so a slow body is still covered by the deadline and
+     * by the caller's `signal`.
+     */
+    private request;
+    /**
+     * Execute a Stripe-style list operation and return its own list envelope
+     * (`data`, `has_more`, `next_cursor`, and the route's extra fields such as
+     * `facets` or `totals`). Use `paginate()` (in `pagination.ts`) to
+     * auto-follow `next_cursor`.
+     */
+    list<K extends ListOperationId>(operationId: K, ...options: OperationOptionsArgs<K, OperationRequestOptions<K>>): Promise<OperationEnvelope<K>>;
+    /** The untyped form; see the second `call` signature. */
+    list<T = unknown, I extends ApiOperationId = ApiOperationId>(operationId: RuntimeOperationId<I>, options?: ApiRequestOptions): Promise<ApiListEnvelope<T>>;
+    getTrader(address: OperationPath["getTrader"]["address"], options?: Omit<OperationRequestOptions<"getTrader">, "path">): Promise<OperationResult<"getTrader">>;
+    getTraderPnl(address: OperationPath["getTraderPnl"]["address"], options?: Omit<OperationRequestOptions<"getTraderPnl">, "path">): Promise<OperationResult<"getTraderPnl">>;
+    /**
+     * Fetch one wallet's win record per canonical category.
+     *
+     * Counts every settled market at any position size, so it can differ from
+     * `category_strengths` on `getTrader`, which reads the floored calibration
+     * sample. A category under `min_decided_for_win_rate` keeps its `wins` and
+     * `decided` with `win_rate: null` and `status: "not_enough_data"`; a category
+     * the wallet has no settled market in is absent, which means no record rather
+     * than a 0% record. The `Esports` record carries `games`: the wallet's record
+     * per esports title (`LoL`, `CS2`, `Dota 2`, ...) under the same rule, named
+     * as the holder chips name them in `category_win_rate_game`. Pass
+     * `params.category` to filter to one bucket; a filter that reaches Esports
+     * returns its games too.
+     */
+    getTraderCategoryRecords(address: OperationPath["getTraderCategoryRecords"]["address"], params?: OperationQuery["getTraderCategoryRecords"], options?: ConvenienceOptions): Promise<OperationResult<"getTraderCategoryRecords">>;
+    /** Read the grade proven visible at one past decision time. */
+    getTraderGradeAt(address: OperationPath["getTraderGradeAt"]["address"], params: OperationQuery["getTraderGradeAt"], options?: ConvenienceOptions): Promise<OperationResult<"getTraderGradeAt">>;
+    /**
+     * Resolve 1 to 25 traders in one request (`POST /api/v1/traders/batch`).
+     *
+     * `traders` is sent as the request body's `traders` array, the field the
+     * route requires: wallet addresses, usernames, `trd_` ids or integer trader
+     * ids, resolved in input order. Until #16135 this method sent the array as
+     * `identifiers`, a field the route does not declare, so every call was
+     * refused for a missing `traders`. `options.expand` is sent as the body's
+     * `expand` array and applies to every item.
+     *
+     * The response `data` keeps request order and one row per input, duplicates
+     * included; a row is `status: "ok"` with `data`, or `status: "error"` with
+     * the item's own `error`. An identity that resolves to nothing is a per-item
+     * error, never a request failure, and since #18135 the route answers the
+     * `not_found` this comment already promised: a username, `trd_` id or
+     * numeric trader id that names no trader is `not_found` with `error.param`
+     * `"traders"`, where it used to be an `ok` row with the input echoed into
+     * `address`. A wallet address the API does not track yet stays `ok` with
+     * `sync_status: "unknown"`, because that address is real and may still be
+     * graded. `meta` is the batch's `BatchResponseMeta`: `request_cost` and
+     * `rate_limit` follow the batch item quota, not the per-request one.
+     */
+    batchGetTraders(traders: OperationBody["batchGetTraders"]["traders"], options?: BatchGetTradersOptions): Promise<OperationResult<"batchGetTraders">>;
+    /**
+     * Resolve up to 25 markets' flow and top positions in one request
+     * (`POST /api/v1/markets/flow/batch`); `meta` is the batch's own.
+     */
+    batchGetMarketFlow(body: OperationBody["batchGetMarketFlow"], options?: ConvenienceOptions): Promise<OperationResult<"batchGetMarketFlow">>;
+    /**
+     * @deprecated Use {@link batchGetMarketFlow} (#16312); calls the deprecated
+     * `POST /api/v1/markets/intel/batch`, whose envelope keeps
+     * `object: "market_intel_batch"`.
+     */
+    batchGetMarketIntel(body: OperationBody["batchGetMarketIntel"], options?: ConvenienceOptions): Promise<OperationResult<"batchGetMarketIntel">>;
+    listLeaderboard(params?: LeaderboardListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listLeaderboard">>;
+    listTrendingWallets(params?: TrendingWalletsParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listTrendingWallets">>;
+    listLargeTrades(params?: LargeTradeListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listLargeTrades">>;
+    /**
+     * Typed conditional-read variant of {@link listLargeTrades}, for polling
+     * (#18507). Returns the list envelope on 200 or the typed `not_modified`
+     * result on 304, where {@link listLargeTrades} throws on a 304. Pass
+     * `since` (the id of the first trade of your last answer that had trades)
+     * with `If-None-Match`: a poll that finds no new trade is a 304 with no body.
+     */
+    listLargeTradesConditional(params?: LargeTradeListParams, options?: ConvenienceOptions): Promise<OperationResult<"listLargeTrades">>;
+    listLargeTradeHistory(params?: LargeTradeHistoryParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listLargeTradeHistory">>;
+    /** @deprecated Use {@link listLargeTrades} (#16304); calls the deprecated `/api/v1/whale-trades`. */
+    listWhaleTrades(params?: WhaleTradeListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listWhaleTrades">>;
+    /** @deprecated Use {@link listLargeTradeHistory} (#16304); calls the deprecated `/api/v1/whale-trades/history`. */
+    listWhaleTradeHistory(params?: WhaleTradeHistoryParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listWhaleTradeHistory">>;
+    listPositions(params?: PositionsListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listPositions">>;
+    listLargePositions(params?: LargePositionsListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listLargePositions">>;
+    /**
+     * List ranked sharp-money flows. Canonical since #16308 ("sharp money" is
+     * the pinned product term); it calls `/api/v1/markets/sharp-money-flows`.
+     */
+    listSharpMoneyFlows(params?: SharpMoneyFlowsParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listSharpMoneyFlows">>;
+    /**
+     * @deprecated Use {@link listSharpMoneyFlows} (#16308). Kept live; it calls
+     * the deprecated `/api/v1/markets/smart-money-flows`, whose responses carry
+     * `Deprecation` and a `Link rel="successor-version"`.
+     */
+    listSmartMoneyFlows(params?: OperationQuery["listSmartMoneyFlows"], options?: ConvenienceOptions): Promise<OperationEnvelope<"listSmartMoneyFlows">>;
+    /**
+     * List covered games: both sides with their provider ids and live scores, the
+     * UTC kickoff, the provider's own status, and every linked Polymarket market
+     * with its condition id and outcome token ids. Ordered by kickoff, then by
+     * `event_slug`, with unscheduled games last. An unknown `sport` or `status`
+     * returns an empty page rather than an error, and the response's `coverage`
+     * names what this deployment serves.
+     */
+    listGames(params?: GamesListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listGames">>;
+    /**
+     * Read one game by its `event_slug`, the identity the `live_sports_updated`
+     * webhook pulse carries. A slug outside the published coverage returns 404.
+     */
+    getGame(eventSlug: OperationPath["getGame"]["event_slug"], options?: ConvenienceOptions): Promise<OperationResult<"getGame">>;
+    /**
+     * List upcoming games ranked by the side profitable wallets hold, with
+     * additive, shadow-only category evidence. `category_skill` never changes
+     * membership, ordering, or sizing. Rows carry `side`, `ranked_at`,
+     * `backing_score` and `side_share`; the older `piled_side`,
+     * `signal_created_at`, `conviction_score` and `smart_score` keys carry the
+     * same values and stay on the wire.
+     */
+    listPreGameSides(params?: PreGameSidesParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listPreGameSides">>;
+    /**
+     * @deprecated Use {@link listPreGameSides} (#16310). Kept live; it calls the
+     * deprecated `/api/v1/sports-edge-signals` path, which answers with
+     * `Deprecation` and successor `Link` headers and the same body.
+     */
+    listSportsEdgeSignals(params?: SportsEdgeSignalsParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listSportsEdgeSignals">>;
+    /**
+     * Read an explicitly observation-only sports cohort and its accountable
+     * per-sport funnel. This surface is isolated from the funded signals route.
+     * Healthy wider-holder and emerging-pile snapshots may be served for about
+     * 180 seconds; in-play cached snapshots are capped at about 30 seconds and
+     * stale provider live-board evidence fails closed. emerging-pile is an
+     * additive wider-holder projection, not an arrival-history or independent
+     * denominator view.
+     */
+    listPreGameSideObservations(params: PreGameSideObservationsParams, options?: ConvenienceOptions): Promise<PreGameSideObservationsResponse>;
+    /**
+     * @deprecated Use {@link listPreGameSideObservations} (#16310). Kept live; it
+     * calls the deprecated `/api/v1/sports-edge-observations` path, which answers
+     * with `Deprecation` and successor `Link` headers and the same body.
+     */
+    listSportsEdgeObservations(params: SportsEdgeObservationsParams, options?: ConvenienceOptions): Promise<SportsEdgeObservationsResponse>;
+    /**
+     * Typed conditional-read variant of {@link listSportsEdgeObservations}.
+     * Returns the full observation response on 200 or a typed `not_modified`
+     * envelope on 304 instead of routing the latter through generic `call()`.
+     * The endpoint emits a weak semantic ETag over the stable response payload;
+     * request-specific `meta` is excluded. For emerging-pile, the opaque
+     * projection cutoff inside `next_cursor` is excluded while its stable page
+     * position remains covered.
+     */
+    listPreGameSideObservationsConditional(params: PreGameSideObservationsParams, options?: ConvenienceOptions): Promise<PreGameSideObservationsResponse | ApiNotModifiedResponse>;
+    /**
+     * @deprecated Use {@link listPreGameSideObservationsConditional} (#16310).
+     * Kept live on the deprecated `/api/v1/sports-edge-observations` path.
+     */
+    listSportsEdgeObservationsConditional(params: SportsEdgeObservationsParams, options?: ConvenienceOptions): Promise<SportsEdgeObservationsResponse | ApiNotModifiedResponse>;
+    searchMarkets(q: OperationQuery["searchMarkets"]["q"], options?: ConvenienceOptions & {
+        query?: Omit<OperationQuery["searchMarkets"], "q">;
+    }): Promise<OperationEnvelope<"searchMarkets">>;
+    searchContent(q: OperationQuery["searchContent"]["q"], options?: ConvenienceOptions & {
+        query?: Omit<OperationQuery["searchContent"], "q">;
+    }): Promise<OperationEnvelope<"searchContent">>;
+    exploreMarkets(params?: ExploreMarketsParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"exploreMarkets">>;
+    /** One market's flow and top positions (`GET /api/v1/market/{condition_id}/flow`). */
+    getMarketFlow(conditionId: OperationPath["getMarketFlow"]["condition_id"], options?: Omit<OperationRequestOptions<"getMarketFlow">, "path">): Promise<OperationResult<"getMarketFlow">>;
+    /**
+     * @deprecated Use {@link getMarketFlow} (#16312); calls the deprecated
+     * `GET /api/v1/market/{condition_id}/intel`, whose envelope keeps
+     * `object: "market_intel"`.
+     */
+    getMarketIntel(conditionId: OperationPath["getMarketIntel"]["condition_id"], options?: Omit<OperationRequestOptions<"getMarketIntel">, "path">): Promise<OperationResult<"getMarketIntel">>;
+    getMarketSnapshot(conditionId: OperationPath["getMarketSnapshot"]["condition_id"], options?: Omit<OperationRequestOptions<"getMarketSnapshot">, "path">): Promise<OperationResult<"getMarketSnapshot">>;
+    /**
+     * One page of a market's graded (S/A/B) holder roster from a complete
+     * provider holder scan: the list a Pick of the Day shows, for any market.
+     * `params.outcome` (`yes` | `no` | `all`), `params.min_grade` (`S` | `A` |
+     * `B`), `params.limit` and `params.cursor` (`mh_` prefix). The page carries
+     * the `market`, `scan` and roster `totals` beside `data`; `total` is the
+     * count matching the filters across every page.
+     */
+    getMarketHolders(conditionId: OperationPath["getMarketHolders"]["condition_id"], params?: OperationQuery["getMarketHolders"], options?: ConvenienceOptions): Promise<OperationEnvelope<"getMarketHolders">>;
+    /**
+     * Fetch bucketed OHLC candles for a market's outcome tokens.
+     * Resolution defaults to the server default; pass `params.resolution` as
+     * `"1d"` or `"1w"` to override. `params.from` is exclusive and `params.to`
+     * is inclusive; when both are present, `from` must be less than or equal to
+     * `to`.
+     */
+    getMarketCandles(conditionId: OperationPath["getMarketCandles"]["condition_id"], params?: OperationQuery["getMarketCandles"], options?: ConvenienceOptions): Promise<OperationResult<"getMarketCandles">>;
+    /**
+     * Fetch one suspicious trade by raw `whale_alerts.id` or the `rf_`-prefixed
+     * id list responses emit. The envelope's `object` is `"suspicious_trade"`.
+     */
+    getSuspiciousTrade(id: OperationPath["getSuspiciousTrade"]["id"], options?: ConvenienceOptions): Promise<OperationResult<"getSuspiciousTrade">>;
+    /** List stored trades whose recorded suspicion score meets the flag threshold. */
+    listSuspiciousTrades(params?: SuspiciousTradesListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listSuspiciousTrades">>;
+    /**
+     * @deprecated Use `getSuspiciousTrade()`; renamed in #16301. This method
+     * keeps calling the deprecated `GET /api/v1/insider-radar/{id}`, which stays
+     * live with no retirement date and still answers `object: "radar_flag"`, so
+     * an integration branching on that envelope keeps working.
+     */
+    getInsiderRadarFlag(id: OperationPath["getInsiderRadarFlag"]["id"], options?: ConvenienceOptions): Promise<OperationResult<"getInsiderRadarFlag">>;
+    /**
+     * @deprecated Use `listSuspiciousTrades()`; renamed in #16301. This method
+     * keeps calling the deprecated `GET /api/v1/insider-radar`, which stays live
+     * with no retirement date and answers with `Deprecation` plus a `Link
+     * rel="successor-version"` header.
+     */
+    listInsiderRadar(params?: InsiderRadarListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listInsiderRadar">>;
+    getLargeTrade(id: OperationPath["getLargeTrade"]["id"], options?: ConvenienceOptions): Promise<OperationResult<"getLargeTrade">>;
+    /** @deprecated Use {@link getLargeTrade} (#16304); calls the deprecated `/api/v1/whale-trades/{id}`. */
+    getWhaleTrade(id: OperationPath["getWhaleTrade"]["id"], options?: ConvenienceOptions): Promise<OperationResult<"getWhaleTrade">>;
+    /**
+     * Cancel a submitted export (`POST /api/v1/trader/{address}/export/cancel`, #16254).
+     *
+     * Resolves to the job resource after the cancel, the same shape
+     * `getTraderExportStatus` returns: `cancelled` for a job no worker had
+     * started, `cancel_requested` for a running one (poll the status route at
+     * `poll_after_s` until it reads `cancelled`), or the job unchanged when a
+     * cancel can no longer reach it (its file is being published, or it is
+     * already terminal). Compare `status` rather than assuming success. A
+     * cancel never deletes a ready file, never returns quota, and is safe to
+     * repeat, so it is retried on a transport or 5xx failure like a read.
+     */
+    cancelTraderExport(address: OperationPath["cancelTraderExport"]["address"], jobId: OperationQuery["cancelTraderExport"]["job_id"], options?: ConvenienceOptions): Promise<OperationResult<"cancelTraderExport">>;
+    listWebhooks(options?: ConvenienceOptions): Promise<OperationEnvelope<"listWebhooks">>;
+    getWebhook(id: OperationPath["getWebhook"]["id"], options?: ConvenienceOptions): Promise<OperationResult<"getWebhook">>;
+    createWebhook(body: OperationBody["createWebhook"], options?: ConvenienceOptions): Promise<OperationResult<"createWebhook">>;
+    updateWebhook(id: OperationPath["updateWebhook"]["id"], body: OperationBody["updateWebhook"], options?: ConvenienceOptions): Promise<OperationResult<"updateWebhook">>;
+    deleteWebhook(id: OperationPath["deleteWebhook"]["id"], options?: ConvenienceOptions): Promise<OperationResult<"deleteWebhook">>;
+    /**
+     * Fetch the self-describing webhook event catalog (each entry's `id`,
+     * description, payload shape, and active/dormant status).
+     */
+    listWebhookEvents(options?: ConvenienceOptions): Promise<OperationEnvelope<"listWebhookEvents">>;
+    /** List delivery attempts for one webhook endpoint (Stripe-style list). */
+    listWebhookDeliveries(webhookId: OperationPath["listWebhookDeliveries"]["id"], params?: OperationQuery["listWebhookDeliveries"], options?: ConvenienceOptions): Promise<OperationEnvelope<"listWebhookDeliveries">>;
+    /**
+     * Requeue one `dead_letter` delivery with a fresh attempt budget and return
+     * the delivery row. Re-enabling a disabled endpoint resends nothing, so this
+     * is how its dead-lettered deliveries are recovered. The API answers 409 when
+     * the delivery is already delivered or still queued, or when the endpoint is
+     * disabled, unverified, or no longer subscribed to the delivery's event type;
+     * the error message names the fix. Pass `idempotencyKey` to make a retry safe.
+     */
+    redeliverWebhookDelivery(webhookId: OperationPath["redeliverWebhookDelivery"]["id"], deliveryId: OperationPath["redeliverWebhookDelivery"]["delivery_id"], options?: ConvenienceOptions): Promise<OperationResult<"redeliverWebhookDelivery">>;
+    getHealth(options?: ConvenienceOptions): Promise<OperationResult<"getHealth">>;
+    getApiDiscovery(options?: ConvenienceOptions): Promise<OperationResult<"getApiDiscovery">>;
+    /**
+     * Which V1 reads the API serves for Polymarket (`GET /api/v1/coverage`).
+     * Public: needs no API key.
+     */
+    getCoverage(options?: ConvenienceOptions): Promise<OperationResult<"getCoverage">>;
+    /**
+     * @deprecated Use {@link getCoverage} (#16315); calls the deprecated
+     * `GET /api/v1/platforms`, which serves the same body.
+     */
+    getPlatforms(options?: ConvenienceOptions): Promise<OperationResult<"getPlatforms">>;
+    getAccountIdentity(options?: ConvenienceOptions): Promise<OperationResult<"getAccountIdentity">>;
+    /**
+     * One wallet's context as Markdown, ready to paste into a model prompt
+     * (`GET /api/v1/trader/{address}/context.md`). The JSON form of the same
+     * read is `getTraderContext`.
+     */
+    getTraderContextMarkdown(address: OperationPath["getTraderContextMarkdown"]["address"], options?: Omit<OperationRequestOptions<"getTraderContextMarkdown">, "path">): Promise<string>;
+    /**
+     * One market's context as Markdown
+     * (`GET /api/v1/market/{condition_id}/context.md`). The JSON form is
+     * `getMarketSnapshot`.
+     */
+    getMarketContextMarkdown(conditionId: OperationPath["getMarketContextMarkdown"]["condition_id"], options?: Omit<OperationRequestOptions<"getMarketContextMarkdown">, "path">): Promise<string>;
+    /**
+     * Mint a sandbox key (`POST /api/v1/agents/register`), the one write that
+     * needs no credential. Answers `201`, which is why the SDK had no method
+     * for it until #16137: the drift gate counted only operations with a
+     * documented `200`. `meta.status` is `201`; `data.api_key` is the
+     * `oxi_sk_test_*` key to pass to `OxinsiderApiClient.sandbox()`.
+     *
+     * Nothing is stored: the key cannot be listed or revoked and does not
+     * expire. Register again for another one.
+     */
+    registerAgent(options?: ConvenienceOptions): Promise<OperationResult<"registerAgent">>;
+    getUsage(options?: ConvenienceOptions): Promise<OperationResult<"getUsage">>;
+    /** Fetch today's editorial Pick of the Day (single-object envelope). */
+    getPickOfTheDay(options?: ConvenienceOptions): Promise<OperationResult<"getPickOfTheDay">>;
+    /** Fetch the Pick of the Day archive with hit-rate (single-object envelope). */
+    getPickOfTheDayArchive(options?: ConvenienceOptions): Promise<OperationResult<"getPickOfTheDayArchive">>;
+    /**
+     * Fetch the Pick of the Day commitment ledger (single-object envelope).
+     *
+     * Every entry is `sealed` (a live pick: the hash, no side and no price),
+     * `opened` (a settled pick: the nonce and the exact hashed payload) or
+     * `uncommitted` (no commitment; once settled, its unhashed side and price
+     * under `payload`). Verify an opened entry by
+     * appending the hex-decoded `commitment_nonce` to the `payload` bytes as
+     * received and hashing with sha256; do not reserialize the payload, since it
+     * is served byte for byte as it was hashed.
+     */
+    getPickOfTheDayLedger(options?: ConvenienceOptions): Promise<OperationResult<"getPickOfTheDayLedger">>;
+    /** Resolve the base URL (used by the SSE stream consumer). */
+    getBaseUrl(): string;
+    /** The configured API key, if any (used by the SSE stream consumer). */
+    getApiKey(): string | undefined;
+    /** Whether this client was built in sandbox mode (#16138). */
+    isSandbox(): boolean;
+    /** The resolved fetch implementation (used by the SSE stream consumer). */
+    getFetch(): typeof fetch;
+    buildUrl(operation: ApiClientOperation, options: ApiRequestOptions): string;
+    private buildHeaders;
+}
+/**
+ * Narrow a `call()` result to the typed 304. Takes any envelope-shaped
+ * value, so it works on an `OperationResult<K>` (whose `meta` is the
+ * operation's own type) as well as the loose `ApiClientResponse<T>`
+ * (#16136).
+ */
+export declare function isApiNotModifiedResponse<R extends {
+    object: string;
+}>(response: R): response is Extract<R, ApiNotModifiedResponse>;
+export declare function interpolatePath(path: string, params: Partial<Record<string, string | number>>): string;
+/**
+ * Whether `body` is a list envelope whose control fields the walker can act
+ * on: `object: "list"`, an array `data`, a BOOLEAN `has_more`, and a
+ * `next_cursor` that is a string, `null` or absent (#16246: the check used to
+ * accept any `has_more` that was merely present, so a malformed value could
+ * be coerced into "no more pages" or "more pages" by truthiness).
+ */
+export declare function isListEnvelope<T>(body: unknown): body is ApiListEnvelope<T>;
+//# sourceMappingURL=client.d.ts.map