@0xinsider/mcp 1.3.1 → 2.0.0

package/dist/sdk/client.d.ts

@@ -0,0 +1,765 @@
+/**
+ * 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 { OperationData, PickOfTheDay, PickOfTheDayArchive, ResponseMeta, SportsEdgeFunnelReport, SportsEdgeObservation, SportsEdgeSignal } 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;
+};
+export type ApiClientMethod = "GET" | "POST" | "PATCH" | "DELETE";
+/** Whether an operation requires the `oxi_sk_*` Bearer key. */
+export type AuthMode = "none" | "bearer";
+export interface ApiClientOperation {
+    readonly method: ApiClientMethod;
+    readonly path: string;
+    readonly operationId: string;
+    readonly auth: AuthMode;
+}
+/**
+ * The full V1 operation table. One row per OpenAPI operation that returns a
+ * `200`. Kept in lockstep with `web/public/api/v1/openapi.json` by
+ * `scripts/check-sdk-openapi-drift.mjs`. Do not add a row without a matching
+ * spec operation, and do not remove a spec operation without removing its row.
+ */
+export declare const API_CLIENT_OPERATIONS: readonly [{
+    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}/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 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: "GET";
+    readonly path: "/api/v1/leaderboard/trending";
+    readonly operationId: "listTrendingWallets";
+    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/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/platforms";
+    readonly operationId: "getPlatforms";
+    readonly auth: "none";
+}, {
+    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/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 method: "GET";
+    readonly path: "/api/v1/market/{condition_id}/candles";
+    readonly operationId: "getMarketCandles";
+    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 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: "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 method: "GET";
+    readonly path: "/api/v1/mcp";
+    readonly operationId: "openMcpEventStream";
+    readonly auth: "bearer";
+}, {
+    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";
+}];
+export type ApiOperationId = (typeof API_CLIENT_OPERATIONS)[number]["operationId"];
+/**
+ * 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>;
+    /** 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. The API honours it on `createWebhook`,
+     * `updateWebhook`, `deleteWebhook`, `rotateWebhookSecret` and
+     * `redeliverWebhookDelivery`: a replay with the same key and body returns the
+     * first result instead of repeating the write.
+     * A write carrying a key is also the only non-GET request the SDK retries.
+     * On `IdempotencyInProgressError`, retry with the SAME key and body.
+     */
+    idempotencyKey?: string;
+}
+export interface ApiClientOptions {
+    /**
+     * API base, e.g. `https://api.0xinsider.com`. Trailing slashes are trimmed.
+     */
+    baseUrl?: string;
+    /** The `oxi_sk_live_*` secret API key. */
+    apiKey?: string;
+    /** 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, or a write carrying an `Idempotency-Key`, that failed with
+     * 429, 502, 503, 504, or a network error before any response. The wait is the
+     * response's `Retry-After` 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 60 s is not waited out; the error is thrown so the caller can
+     * schedule it. Never retried: 400, 401, 402, 403, 404, 409, 500, a write
+     * without a key, a 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";
+/** 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;
+/**
+ * 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;
+}
+export interface SportsEdgeSignalsParams extends ListParams {
+    category?: string;
+    horizon_hours?: number;
+    min_grade?: "S" | "A" | "B";
+}
+/** Observation cohorts exposed by `listSportsEdgeObservations`. */
+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. */
+export interface SportsEdgeObservationsResponse extends ApiListEnvelope<SportsEdgeObservation> {
+    next_cursor: string | null;
+    snapshot_as_of: string;
+    /**
+     * Snapshot-wide operational/unknown-completeness verdict. True means treat
+     * the evidence as partial; fully accounted `capacity_limited` rows alone do
+     * not set it.
+     */
+    degraded: boolean;
+    funnel: SportsEdgeFunnelReport;
+    meta: ClientResponseMeta;
+}
+export interface SportsEdgeObservationsParams extends ListParams {
+    cohort: SportsEdgeObservationCohort;
+    category?: string;
+}
+/**
+ * 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 six items and never more than six.
+ * 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;
+        [key: string]: unknown;
+    };
+}
+export type ApiClientResponse<T> = ApiEnvelope<T> | ApiNotModifiedResponse;
+/** 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`. 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).
+ */
+export interface LeaderboardListParams extends ListParams {
+    category?: string;
+    strategy?: LeaderboardStrategy;
+}
+/** Query parameters for `GET /api/v1/leaderboard/trending`. */
+export interface TrendingWalletsParams extends ListParams {
+    window?: "7d" | "30d";
+}
+/** Query parameters shared by the V1 whale-trade list and history reads. */
+export interface WhaleTradeListParams extends ListParams {
+    min_size?: number;
+    category?: string;
+    min_grade?: Grade;
+    /** Keep only rows with persisted suspicion_score >= 60. */
+    suspicious_only?: boolean;
+}
+/** Query parameters for the V1 historical whale-trade replay. */
+export interface WhaleTradeHistoryParams extends WhaleTradeListParams {
+    condition_id?: string;
+    trader?: string;
+    from?: string;
+    to?: string;
+    platform?: "polymarket" | "all";
+}
+export declare class OxinsiderApiClient {
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    constructor(options?: ApiClientOptions);
+    /**
+     * Execute any 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 parsed `{ object, data, meta }` envelope.
+     */
+    call<T>(operationId: ApiOperationId, options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    /**
+     * Execute a Stripe-style list operation and return the list envelope.
+     * Use `paginate()` (in `pagination.ts`) to auto-follow `next_cursor`.
+     */
+    list<T>(operationId: ApiOperationId, options?: ApiRequestOptions): Promise<ApiListEnvelope<T>>;
+    getTrader<T = OperationData["getTrader"]>(address: string, options?: Omit<ApiRequestOptions, "path">): Promise<ApiClientResponse<T>>;
+    getTraderPnl<T = OperationData["getTraderPnl"]>(address: string, options?: Omit<ApiRequestOptions, "path">): Promise<ApiClientResponse<T>>;
+    batchGetTraders<T = OperationData["batchGetTraders"]>(identifiers: readonly string[], options?: Omit<ApiRequestOptions, "body">): Promise<ApiClientResponse<T>>;
+    listLeaderboard<T = OperationData["listLeaderboard"][number]>(params?: LeaderboardListParams): Promise<ApiListEnvelope<T>>;
+    listTrendingWallets<T = OperationData["listTrendingWallets"][number]>(params?: TrendingWalletsParams): Promise<ApiListEnvelope<T>>;
+    listWhaleTrades<T = OperationData["listWhaleTrades"][number]>(params?: WhaleTradeListParams): Promise<ApiListEnvelope<T>>;
+    listWhaleTradeHistory<T = OperationData["listWhaleTradeHistory"][number]>(params?: WhaleTradeHistoryParams): Promise<ApiListEnvelope<T>>;
+    listPositions<T = OperationData["listPositions"][number]>(params?: ListParams & {
+        min_grade?: Grade;
+    }): Promise<ApiListEnvelope<T>>;
+    listLargePositions<T = OperationData["listLargePositions"][number]>(params?: ListParams & {
+        min_grade?: Grade;
+    }): Promise<ApiListEnvelope<T>>;
+    listSmartMoneyFlows<T = OperationData["listSmartMoneyFlows"][number]>(params?: ListParams & {
+        min_grade?: Grade;
+    }): Promise<ApiListEnvelope<T>>;
+    /** Canonical alias of {@link listSmartMoneyFlows} (epic #6912). */
+    listSharpMoneyFlows<T = OperationData["listSharpMoneyFlows"][number]>(params?: ListParams & {
+        min_grade?: Grade;
+    }): Promise<ApiListEnvelope<T>>;
+    /**
+     * List the funded-primary sports signals with additive, shadow-only category
+     * evidence. `category_skill` never changes membership, ordering, or sizing.
+     */
+    listSportsEdgeSignals(params?: SportsEdgeSignalsParams): Promise<ApiListEnvelope<SportsEdgeSignal>>;
+    /**
+     * 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.
+     */
+    listSportsEdgeObservations(params: SportsEdgeObservationsParams, options?: Omit<ApiRequestOptions, "query">): 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.
+     */
+    listSportsEdgeObservationsConditional(params: SportsEdgeObservationsParams, options?: Omit<ApiRequestOptions, "query">): Promise<SportsEdgeObservationsResponse | ApiNotModifiedResponse>;
+    searchMarkets<T = OperationData["searchMarkets"]>(q: string, options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    exploreMarkets<T = OperationData["getMarketIntel"]>(params?: ListParams): Promise<ApiListEnvelope<T>>;
+    getMarketIntel<T = OperationData["getMarketIntel"]>(conditionId: string, options?: Omit<ApiRequestOptions, "path">): Promise<ApiClientResponse<T>>;
+    getMarketSnapshot<T = OperationData["getMarketSnapshot"]>(conditionId: string, options?: Omit<ApiRequestOptions, "path">): Promise<ApiClientResponse<T>>;
+    /**
+     * Fetch bucketed OHLC candles for a market's outcome tokens.
+     * Resolution defaults to the server default; pass `query.resolution` as
+     * `"1d"` or `"1w"` to override.
+     */
+    getMarketCandles<T = OperationData["getMarketCandles"]>(conditionId: string, options?: Omit<ApiRequestOptions, "path">): Promise<ApiClientResponse<T>>;
+    getInsiderRadarFlag<T = OperationData["getInsiderRadarFlag"]>(id: string, options?: Omit<ApiRequestOptions, "path">): Promise<ApiClientResponse<T>>;
+    listInsiderRadar<T = OperationData["listWebhooks"]>(params?: ListParams & {
+        min_grade?: Grade;
+    }): Promise<ApiListEnvelope<T>>;
+    listWebhooks<T = OperationData["listWebhooks"]>(options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    /**
+     * Fetch the self-describing webhook event catalog (each entry's `id`,
+     * description, payload shape, and active/dormant status).
+     */
+    listWebhookEvents<T = OperationData["listWebhookEvents"]>(options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    /** List delivery attempts for one webhook endpoint (Stripe-style list). */
+    listWebhookDeliveries<T = OperationData["redeliverWebhookDelivery"]>(webhookId: string | number, params?: ListParams): Promise<ApiListEnvelope<T>>;
+    /**
+     * 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<T = OperationData["redeliverWebhookDelivery"]>(webhookId: string | number, deliveryId: string | number, options?: Omit<ApiRequestOptions, "path" | "body">): Promise<ApiClientResponse<T>>;
+    getHealth<T = OperationData["getHealth"]>(options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    getApiDiscovery<T = OperationData["getApiDiscovery"]>(options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    getAccountIdentity(options?: ApiRequestOptions): Promise<ApiClientResponse<{
+        user_id: number;
+        credential_id: number;
+        credential_kind: "api_key" | "oauth_grant";
+        scopes: string[] | null;
+    }>>;
+    getUsage<T = OperationData["getUsage"]>(options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    /** Fetch today's editorial Pick of the Day (single-object envelope). */
+    getPickOfTheDay<T = PickOfTheDay>(options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    /** Fetch the Pick of the Day archive with hit-rate (single-object envelope). */
+    getPickOfTheDayArchive<T = PickOfTheDayArchive>(options?: ApiRequestOptions): Promise<ApiClientResponse<T>>;
+    /** 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;
+    /** The resolved fetch implementation (used by the SSE stream consumer). */
+    getFetch(): typeof fetch;
+    buildUrl(operation: ApiClientOperation, options: ApiRequestOptions): string;
+    private buildHeaders;
+}
+export declare function isApiNotModifiedResponse(response: ApiClientResponse<unknown>): response is ApiNotModifiedResponse;
+export declare function interpolatePath(path: string, params: Partial<Record<string, string | number>>): string;
+export declare function isListEnvelope<T>(body: unknown): body is ApiListEnvelope<T>;
+//# sourceMappingURL=client.d.ts.map