@0xinsider/mcp 1.3.1 → 2.0.0

package/dist/sdk/client.js

@@ -0,0 +1,974 @@
+/**
+ * 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 { errorFromResponse, OxinsiderApiError, RequestTimeoutError, } from "./errors.js";
+/**
+ * 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 const API_CLIENT_OPERATIONS = [
+    { method: "GET", path: "/api/v1/me", operationId: "getAccountIdentity", auth: "bearer" },
+    {
+        method: "GET",
+        path: "/api/v1",
+        operationId: "getApiDiscovery",
+        auth: "none",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/trader/{address}",
+        operationId: "getTrader",
+        auth: "bearer",
+    },
+    {
+        method: "POST",
+        path: "/api/v1/traders/batch",
+        operationId: "batchGetTraders",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/trader/{address}/position-timeline",
+        operationId: "getPositionTimeline",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/traders/{trader}/position-timeline",
+        operationId: "getPositionTimelineById",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/positions",
+        operationId: "listPositions",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/large-positions",
+        operationId: "listLargePositions",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/trader/{address}/pnl",
+        operationId: "getTraderPnl",
+        auth: "bearer",
+    },
+    // Pre-existing op-table drift (surfaced by test/drift.test.ts, #6915): these
+    // 200-returning openapi operations were never mirrored into the client table.
+    // Added so the table stays contract-complete against the checked-in spec. All
+    // inherit the global `bearerAuth` security (no per-op `security: []` override,
+    // and none are in the backend public-path allowlist), so auth is "bearer".
+    // The drift check intentionally excludes the redirect-only routes (openapi-spec
+    // redirect + export/download, no 200 response), so they are NOT added here.
+    {
+        method: "GET",
+        path: "/api/v1/trader/{address}/context",
+        operationId: "getTraderContext",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/trader/{address}/context.md",
+        operationId: "getTraderContextMarkdown",
+        auth: "bearer",
+    },
+    {
+        method: "POST",
+        path: "/api/v1/trader/{address}/export",
+        operationId: "submitTraderExport",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/trader/{address}/export/status",
+        operationId: "getTraderExportStatus",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/leaderboard/trending",
+        operationId: "listTrendingWallets",
+        auth: "bearer",
+    },
+    // Pre-existing gap, fixed here (#7209): the route has shipped in openapi.json,
+    // llms-full.txt, agents.md, and the discovery doc, but never in the SDK table --
+    // so `drift.test.ts` was RED on main and SDK users had no typed method for it.
+    {
+        method: "GET",
+        path: "/api/v1/sports-edge-signals",
+        operationId: "listSportsEdgeSignals",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/sports-edge-observations",
+        operationId: "listSportsEdgeObservations",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/whale-trades",
+        operationId: "listWhaleTrades",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/whale-trades/history",
+        operationId: "listWhaleTradeHistory",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/whale-trades/{id}/counterparties/executions",
+        operationId: "listWhaleTradeCounterpartyExecutions",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/whale-trades/{id}/counterparties/executions/{execution_id}/makers",
+        operationId: "listWhaleTradeCounterpartyMakers",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/content/search",
+        operationId: "searchContent",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/whale-trades/{id}",
+        operationId: "getWhaleTrade",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/leaderboard",
+        operationId: "listLeaderboard",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/markets/search",
+        operationId: "searchMarkets",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/markets/explore",
+        operationId: "exploreMarkets",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/markets/smart-money-flows",
+        operationId: "listSmartMoneyFlows",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/markets/sharp-money-flows",
+        operationId: "listSharpMoneyFlows",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/platforms",
+        operationId: "getPlatforms",
+        auth: "none",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/market/{condition_id}/intel",
+        operationId: "getMarketIntel",
+        auth: "bearer",
+    },
+    {
+        method: "POST",
+        path: "/api/v1/markets/intel/batch",
+        operationId: "batchGetMarketIntel",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/market/{condition_id}/snapshot",
+        operationId: "getMarketSnapshot",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/market/{condition_id}/context.md",
+        operationId: "getMarketContextMarkdown",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/market/{condition_id}/candles",
+        operationId: "getMarketCandles",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/insider-radar",
+        operationId: "listInsiderRadar",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/insider-radar/{id}",
+        operationId: "getInsiderRadarFlag",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/events/feed/since",
+        operationId: "getEventReplaySince",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/stream",
+        operationId: "getStream",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/webhooks",
+        operationId: "listWebhooks",
+        auth: "bearer",
+    },
+    {
+        method: "POST",
+        path: "/api/v1/webhooks",
+        operationId: "createWebhook",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/webhooks/{id}",
+        operationId: "getWebhook",
+        auth: "bearer",
+    },
+    {
+        method: "PATCH",
+        path: "/api/v1/webhooks/{id}",
+        operationId: "updateWebhook",
+        auth: "bearer",
+    },
+    {
+        method: "DELETE",
+        path: "/api/v1/webhooks/{id}",
+        operationId: "deleteWebhook",
+        auth: "bearer",
+    },
+    {
+        method: "POST",
+        path: "/api/v1/webhooks/{id}/verify",
+        operationId: "verifyWebhook",
+        auth: "bearer",
+    },
+    {
+        method: "POST",
+        path: "/api/v1/webhooks/{id}/rotate-secret",
+        operationId: "rotateWebhookSecret",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/webhooks/events",
+        operationId: "listWebhookEvents",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/webhooks/{id}/deliveries",
+        operationId: "listWebhookDeliveries",
+        auth: "bearer",
+    },
+    {
+        method: "POST",
+        path: "/api/v1/webhooks/{id}/deliveries/{delivery_id}/redeliver",
+        operationId: "redeliverWebhookDelivery",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/health",
+        operationId: "getHealth",
+        auth: "none",
+    },
+    {
+        method: "POST",
+        path: "/api/v1/mcp",
+        operationId: "createMcpJsonRpcResponse",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/mcp",
+        operationId: "openMcpEventStream",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/reports",
+        operationId: "getReports",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/reports/daily",
+        operationId: "getDailyReportSnapshot",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/reports/weekly",
+        operationId: "getWeeklyReportSnapshot",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/reports/monthly",
+        operationId: "getMonthlyReportSnapshot",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/trader/{address}/export",
+        operationId: "getTraderExportSnapshot",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/usage",
+        operationId: "getUsage",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/pick-of-the-day",
+        operationId: "getPickOfTheDay",
+        auth: "bearer",
+    },
+    {
+        method: "GET",
+        path: "/api/v1/pick-of-the-day/archive",
+        operationId: "getPickOfTheDayArchive",
+        auth: "bearer",
+    },
+];
+/**
+ * Trader skill grade. Source of truth:
+ * `components.schemas.Trader.properties.grade.enum` (S highest, F lowest).
+ */
+export const GRADES = ["S", "A", "B", "C", "D", "F"];
+/** Default production API base used when `baseUrl` is omitted. */
+export const DEFAULT_BASE_URL = "https://api.0xinsider.com";
+/** Default per-request deadline; see `ApiClientOptions.timeoutMs`. */
+export const DEFAULT_TIMEOUT_MS = 15_000;
+/** Default retry budget; see `ApiClientOptions.maxRetries`. */
+export const DEFAULT_MAX_RETRIES = 2;
+/** Statuses a retry can fix: rate limited, or a gateway/availability failure. */
+const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
+const RETRY_BASE_DELAY_MS = 500;
+const RETRY_MAX_BACKOFF_MS = 8_000;
+const RETRY_JITTER_MS = 250;
+/** A server-requested wait longer than this is the caller's to schedule. */
+const RETRY_AFTER_CEILING_MS = 60_000;
+function assertRetryCount(value, source) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${source} must be a non-negative integer, got ${String(value)}`);
+    }
+    return value;
+}
+/**
+ * Milliseconds to wait before retry `attempt` (0-based), or `null` when the
+ * server asked for a wait a retry loop should not hold.
+ */
+function retryDelayMs(attempt, retryAfter) {
+    if (retryAfter !== null) {
+        const requested = Math.max(0, retryAfter * 1000);
+        if (requested > RETRY_AFTER_CEILING_MS)
+            return null;
+        return requested + Math.random() * RETRY_JITTER_MS;
+    }
+    const ceiling = Math.min(RETRY_MAX_BACKOFF_MS, RETRY_BASE_DELAY_MS * 2 ** attempt);
+    return ceiling / 2 + Math.random() * (ceiling / 2);
+}
+/** Resolve after `ms`, or reject with the signal's reason the moment it aborts. */
+function sleepUnlessAborted(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function isLoopbackHost(hostname) {
+    const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    return (host === "localhost" ||
+        host === "::1" ||
+        /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host));
+}
+/**
+ * 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 function assertTrustedBaseUrl(baseUrl) {
+    let url;
+    try {
+        url = new URL(baseUrl);
+    }
+    catch {
+        throw new Error(`0xinsider API baseUrl is not a valid URL: ${baseUrl}`);
+    }
+    if (url.protocol === "https:")
+        return url;
+    if (url.protocol === "http:" && isLoopbackHost(url.hostname))
+        return url;
+    throw new Error(`Refusing to send the API key to ${url.origin}: baseUrl must use https: (http: is accepted only for a loopback host such as localhost or 127.0.0.1).`);
+}
+/**
+ * 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 function composeSignals(timeoutMs, caller) {
+    return composeRequestSignal(timeoutMs, caller).signal;
+}
+/** Keep cancellation live through body consumption, then release its listeners. */
+function composeRequestSignal(timeoutMs, caller) {
+    const timeout = timeoutMs === null ? undefined : AbortSignal.timeout(timeoutMs);
+    if (!timeout)
+        return { signal: caller };
+    if (!caller)
+        return { signal: timeout };
+    if (typeof AbortSignal.any === "function") {
+        return { signal: AbortSignal.any([caller, timeout]) };
+    }
+    const controller = new AbortController();
+    const dispose = () => {
+        caller.removeEventListener("abort", onCallerAbort);
+        timeout.removeEventListener("abort", onTimeoutAbort);
+    };
+    const onCallerAbort = () => {
+        dispose();
+        controller.abort(caller.reason);
+    };
+    const onTimeoutAbort = () => {
+        dispose();
+        controller.abort(timeout.reason);
+    };
+    if (caller.aborted) {
+        onCallerAbort();
+    }
+    else if (timeout.aborted) {
+        onTimeoutAbort();
+    }
+    else {
+        caller.addEventListener("abort", onCallerAbort, { once: true });
+        timeout.addEventListener("abort", onTimeoutAbort, { once: true });
+    }
+    return { signal: controller.signal, dispose };
+}
+function isTimeoutAbort(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        error.name === "TimeoutError");
+}
+/** `GET /api/v1/leaderboard` -> parameters -> strategy (`web/public/api/v1/openapi.json`). */
+export const LEADERBOARD_STRATEGIES = [
+    "accumulator",
+    "algo_trader",
+    "arbitrageur",
+    "directional",
+    "event_driven",
+    "market_maker",
+    "momentum",
+    "scalper",
+    "speculator",
+    "swing_trader",
+];
+const operationsById = new Map(API_CLIENT_OPERATIONS.map((operation) => [operation.operationId, operation]));
+export class OxinsiderApiClient {
+    baseUrl;
+    apiKey;
+    fetchImpl;
+    timeoutMs;
+    maxRetries;
+    constructor(options = {}) {
+        const base = assertTrustedBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL);
+        this.baseUrl = base.toString().replace(/\/+$/, "");
+        this.apiKey = options.apiKey;
+        this.timeoutMs =
+            options.timeoutMs === undefined ? DEFAULT_TIMEOUT_MS : options.timeoutMs;
+        this.maxRetries = assertRetryCount(options.maxRetries ?? DEFAULT_MAX_RETRIES, "maxRetries");
+        const fetchImpl = options.fetch ?? globalThis.fetch;
+        if (typeof fetchImpl !== "function") {
+            throw new Error("No fetch implementation available. Pass `fetch` in OxinsiderApiClient options or run on Node 18+ / a fetch-capable runtime.");
+        }
+        // Bind so a passed-through `globalThis.fetch` keeps its receiver.
+        this.fetchImpl = fetchImpl.bind(globalThis);
+    }
+    /**
+     * 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.
+     */
+    async call(operationId, options = {}) {
+        const operation = operationsById.get(operationId);
+        if (!operation) {
+            throw new Error(`Unknown 0xinsider API operation: ${operationId}`);
+        }
+        if (operation.auth === "bearer" && !this.apiKey) {
+            throw new Error(`${operationId} requires an API key (oxi_sk_*)`);
+        }
+        const timeoutMs = options.timeoutMs === undefined ? this.timeoutMs : options.timeoutMs;
+        const maxRetries = options.maxRetries === undefined
+            ? this.maxRetries
+            : assertRetryCount(options.maxRetries, "maxRetries");
+        const url = this.buildUrl(operation, options);
+        const headers = this.buildHeaders(operation, options);
+        const body = options.body === undefined ? undefined : JSON.stringify(options.body);
+        // Replaying a write without a key could repeat it (a second webhook
+        // endpoint, say), so only a GET or a keyed write is retried (#14281).
+        const retryable = operation.method === "GET" || headers.has("idempotency-key");
+        // One deadline for every attempt: a retry that cannot finish before it is
+        // not started, so the caller sees the real failure, not a timeout.
+        const deadlineAt = timeoutMs === null ? null : Date.now() + timeoutMs;
+        const retryDelayWithinBudget = (attempt, retryAfter) => {
+            if (!retryable || attempt >= maxRetries)
+                return null;
+            const delay = retryDelayMs(attempt, retryAfter);
+            if (delay === null)
+                return null;
+            if (deadlineAt !== null && Date.now() + delay >= deadlineAt)
+                return null;
+            return delay;
+        };
+        const requestSignal = composeRequestSignal(timeoutMs, options.signal);
+        try {
+            let response;
+            for (let attempt = 0;; attempt += 1) {
+                try {
+                    response = await this.fetchImpl(url, {
+                        method: operation.method,
+                        headers,
+                        body,
+                        signal: requestSignal.signal,
+                    });
+                }
+                catch (error) {
+                    // A timeout or caller abort is final; the handler below maps it.
+                    if (requestSignal.signal?.aborted || isTimeoutAbort(error))
+                        throw error;
+                    const delay = retryDelayWithinBudget(attempt, null);
+                    if (delay === null)
+                        throw error;
+                    await sleepUnlessAborted(delay, requestSignal.signal);
+                    continue;
+                }
+                if (response.ok || response.status === 304)
+                    break;
+                const errorBody = await parseJson(response);
+                const retryAfter = retryAfterSeconds(response);
+                const delay = RETRYABLE_STATUSES.has(response.status)
+                    ? retryDelayWithinBudget(attempt, retryAfter)
+                    : null;
+                if (delay === null) {
+                    throw errorFromResponse(response.status, errorBody, retryAfter);
+                }
+                await sleepUnlessAborted(delay, requestSignal.signal);
+            }
+            if (response.status === 304) {
+                return notModifiedResponse(response);
+            }
+            const envelope = await parseJson(response);
+            if (isApiEnvelope(envelope)) {
+                const etag = response.headers.get("etag");
+                // Only ADD to a meta the server actually sent. The contract makes
+                // `meta` required on every envelope, so synthesizing one from `?? {}`
+                // would hand a caller a `ResponseMeta` missing its required fields --
+                // which is what the hand-written type hid before #14278.
+                if (etag && envelope.meta) {
+                    envelope.meta = { ...envelope.meta, etag };
+                }
+                return envelope;
+            }
+            throw new OxinsiderApiError(response.status, envelope);
+        }
+        catch (error) {
+            if (timeoutMs !== null &&
+                (isTimeoutAbort(error) ||
+                    (requestSignal.signal?.aborted &&
+                        isTimeoutAbort(requestSignal.signal.reason)))) {
+                throw new RequestTimeoutError(operationId, timeoutMs);
+            }
+            if (requestSignal.signal?.aborted) {
+                throw requestSignal.signal.reason;
+            }
+            throw error;
+        }
+        finally {
+            requestSignal.dispose?.();
+        }
+    }
+    /**
+     * Execute a Stripe-style list operation and return the list envelope.
+     * Use `paginate()` (in `pagination.ts`) to auto-follow `next_cursor`.
+     */
+    async list(operationId, options = {}) {
+        const result = await this.call(operationId, options);
+        if (isNotModified(result)) {
+            throw new OxinsiderApiError(304, "list() received a 304 not_modified; use call() if you send If-None-Match on a list endpoint");
+        }
+        if (!isListEnvelope(result)) {
+            throw new OxinsiderApiError(200, `Operation ${operationId} did not return a list envelope`);
+        }
+        return result;
+    }
+    // --- Typed convenience methods (key surfaces) ---
+    getTrader(address, options = {}) {
+        return this.call("getTrader", { ...options, path: { address } });
+    }
+    getTraderPnl(address, options = {}) {
+        return this.call("getTraderPnl", { ...options, path: { address } });
+    }
+    batchGetTraders(identifiers, options = {}) {
+        return this.call("batchGetTraders", {
+            ...options,
+            body: { identifiers },
+        });
+    }
+    listLeaderboard(params = {}) {
+        return this.list("listLeaderboard", { query: params });
+    }
+    listTrendingWallets(params = {}) {
+        return this.list("listTrendingWallets", { query: params });
+    }
+    listWhaleTrades(params = {}) {
+        return this.list("listWhaleTrades", { query: params });
+    }
+    listWhaleTradeHistory(params = {}) {
+        return this.list("listWhaleTradeHistory", { query: params });
+    }
+    listPositions(params = {}) {
+        return this.list("listPositions", { query: params });
+    }
+    listLargePositions(params = {}) {
+        return this.list("listLargePositions", { query: params });
+    }
+    listSmartMoneyFlows(params = {}) {
+        return this.list("listSmartMoneyFlows", { query: params });
+    }
+    /** Canonical alias of {@link listSmartMoneyFlows} (epic #6912). */
+    listSharpMoneyFlows(params = {}) {
+        return this.list("listSharpMoneyFlows", { query: params });
+    }
+    /**
+     * List the funded-primary sports signals with additive, shadow-only category
+     * evidence. `category_skill` never changes membership, ordering, or sizing.
+     */
+    listSportsEdgeSignals(params = {}) {
+        return this.list("listSportsEdgeSignals", {
+            query: params,
+        });
+    }
+    /**
+     * 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.
+     */
+    async listSportsEdgeObservations(params, options = {}) {
+        const response = await this.list("listSportsEdgeObservations", { ...options, query: params });
+        return sportsEdgeObservationsResponse(response);
+    }
+    /**
+     * 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.
+     */
+    async listSportsEdgeObservationsConditional(params, options = {}) {
+        const response = await this.call("listSportsEdgeObservations", { ...options, query: params });
+        if (isNotModified(response)) {
+            return response;
+        }
+        if (!isListEnvelope(response)) {
+            throw new OxinsiderApiError(200, "listSportsEdgeObservations did not return a list envelope");
+        }
+        return sportsEdgeObservationsResponse(response);
+    }
+    searchMarkets(q, options = {}) {
+        return this.call("searchMarkets", {
+            ...options,
+            query: { q, ...options.query },
+        });
+    }
+    exploreMarkets(params = {}) {
+        return this.list("exploreMarkets", { query: params });
+    }
+    getMarketIntel(conditionId, options = {}) {
+        return this.call("getMarketIntel", {
+            ...options,
+            path: { condition_id: conditionId },
+        });
+    }
+    getMarketSnapshot(conditionId, options = {}) {
+        return this.call("getMarketSnapshot", {
+            ...options,
+            path: { condition_id: conditionId },
+        });
+    }
+    /**
+     * 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(conditionId, options = {}) {
+        return this.call("getMarketCandles", {
+            ...options,
+            path: { condition_id: conditionId },
+        });
+    }
+    getInsiderRadarFlag(id, options = {}) {
+        return this.call("getInsiderRadarFlag", { ...options, path: { id } });
+    }
+    listInsiderRadar(params = {}) {
+        return this.list("listInsiderRadar", { query: params });
+    }
+    // --- Webhooks ---
+    listWebhooks(options = {}) {
+        return this.call("listWebhooks", options);
+    }
+    /**
+     * Fetch the self-describing webhook event catalog (each entry's `id`,
+     * description, payload shape, and active/dormant status).
+     */
+    listWebhookEvents(options = {}) {
+        return this.call("listWebhookEvents", options);
+    }
+    /** List delivery attempts for one webhook endpoint (Stripe-style list). */
+    listWebhookDeliveries(webhookId, params = {}) {
+        return this.list("listWebhookDeliveries", {
+            path: { id: webhookId },
+            query: params,
+        });
+    }
+    /**
+     * 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, deliveryId, options = {}) {
+        return this.call("redeliverWebhookDelivery", {
+            ...options,
+            path: { id: webhookId, delivery_id: deliveryId },
+        });
+    }
+    // --- System ---
+    getHealth(options = {}) {
+        return this.call("getHealth", options);
+    }
+    getApiDiscovery(options = {}) {
+        return this.call("getApiDiscovery", options);
+    }
+    getAccountIdentity(options = {}) {
+        return this.call("getAccountIdentity", options);
+    }
+    getUsage(options = {}) {
+        return this.call("getUsage", options);
+    }
+    /** Fetch today's editorial Pick of the Day (single-object envelope). */
+    getPickOfTheDay(options = {}) {
+        return this.call("getPickOfTheDay", options);
+    }
+    /** Fetch the Pick of the Day archive with hit-rate (single-object envelope). */
+    getPickOfTheDayArchive(options = {}) {
+        return this.call("getPickOfTheDayArchive", options);
+    }
+    // --- Internals ---
+    /** Resolve the base URL (used by the SSE stream consumer). */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    /** The configured API key, if any (used by the SSE stream consumer). */
+    getApiKey() {
+        return this.apiKey;
+    }
+    /** The resolved fetch implementation (used by the SSE stream consumer). */
+    getFetch() {
+        return this.fetchImpl;
+    }
+    buildUrl(operation, options) {
+        const url = new URL(interpolatePath(operation.path, options.path ?? {}), `${this.baseUrl}/`);
+        for (const [key, value] of Object.entries(options.query ?? {})) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    url.searchParams.append(key, String(item));
+                }
+            }
+            else {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return url.toString();
+    }
+    buildHeaders(operation, options) {
+        const headers = new Headers(options.headers);
+        headers.set("accept", "application/json");
+        if (options.body !== undefined && !headers.has("content-type")) {
+            headers.set("content-type", "application/json");
+        }
+        if (operation.auth === "bearer" && this.apiKey) {
+            headers.set("authorization", `Bearer ${this.apiKey}`);
+        }
+        if (options.idempotencyKey !== undefined) {
+            headers.set("idempotency-key", options.idempotencyKey);
+        }
+        return headers;
+    }
+}
+export function isApiNotModifiedResponse(response) {
+    return response.object === "not_modified";
+}
+function isNotModified(response) {
+    return response.object === "not_modified";
+}
+export function interpolatePath(path, params) {
+    return path.replace(/\{([^}]+)\}/g, (_, name) => {
+        const value = params[name];
+        if (value === undefined) {
+            throw new Error(`Missing path parameter: ${name}`);
+        }
+        return encodeURIComponent(String(value));
+    });
+}
+async function parseJson(response) {
+    const text = await response.text();
+    if (text === "") {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function retryAfterSeconds(response) {
+    const header = response.headers.get("retry-after");
+    if (!header)
+        return null;
+    const seconds = Number(header);
+    return Number.isFinite(seconds) ? seconds : null;
+}
+function notModifiedResponse(response) {
+    const meta = { status: 304 };
+    const etag = response.headers.get("etag");
+    if (etag) {
+        meta.etag = etag;
+    }
+    const requestId = response.headers.get("x-request-id");
+    if (requestId) {
+        meta.request_id = requestId;
+    }
+    return { object: "not_modified", data: null, meta };
+}
+function isApiEnvelope(body) {
+    return (typeof body === "object" &&
+        body !== null &&
+        "object" in body &&
+        "data" in body);
+}
+export function isListEnvelope(body) {
+    return (typeof body === "object" &&
+        body !== null &&
+        "object" in body &&
+        body.object === "list" &&
+        "data" in body &&
+        Array.isArray(body.data) &&
+        "has_more" in body);
+}
+function sportsEdgeObservationsResponse(response) {
+    const candidate = response;
+    const funnel = candidate.funnel;
+    const meta = candidate.meta;
+    if (candidate.object !== "list" ||
+        !Array.isArray(candidate.data) ||
+        typeof candidate.has_more !== "boolean" ||
+        !(candidate.next_cursor === null ||
+            typeof candidate.next_cursor === "string") ||
+        typeof candidate.snapshot_as_of !== "string" ||
+        typeof candidate.degraded !== "boolean" ||
+        typeof funnel !== "object" ||
+        funnel === null ||
+        Array.isArray(funnel) ||
+        !Array.isArray(funnel.sports) ||
+        typeof meta !== "object" ||
+        meta === null ||
+        Array.isArray(meta) ||
+        typeof meta.request_id !== "string" ||
+        typeof meta.cached !== "boolean" ||
+        typeof meta.cost !== "number" ||
+        !Number.isInteger(meta.cost)) {
+        throw new OxinsiderApiError(200, {
+            object: "error",
+            error: {
+                code: "invalid_response",
+                message: "listSportsEdgeObservations returned an invalid required response envelope",
+            },
+        });
+    }
+    return response;
+}
+//# sourceMappingURL=client.js.map