@0xinsider/sdk 0.20.0 → 0.22.0

package/README.md

@@ -234,10 +234,10 @@ if (board.object === "edge_hunter") {
 }
 ```
 
-The board covers all sports and esports, uses a fixed B grade floor, and returns
-at most 30 ranked rows. `total` counts rows before that cap. `horizon_hours`
-defaults to 48 and is clamped to 1..48. There is no category, cohort, cursor,
-limit, or minimum-grade option, and this endpoint does not provide an ETag.
+The board defaults cover all sports and esports with a B grade floor and at most
+30 ranked rows. `total` counts selected admitted rows before the cap.
+`horizon_hours` defaults to 48 and clamps to 1..48; `min_grade` accepts S/A/B
+and `limit` defaults to 30 and clamps to 1..30. The board has no ETag or pagination.
 
 Every row includes provider participants, both outcome quotes, and backed-side
 analytics. Current prices are decimal strings with their own `basis`, `ts`,
@@ -251,6 +251,101 @@ A Pro credential throws `MaxPlanRequiredError` (403 `forbidden`,
 same key. All four previous sports-edge and pre-game-side paths are retired
 and return 410 `endpoint_retired`. Their list and conditional-read methods
 were removed in SDK 0.20.0. Migrate to `client.edgeHunter.get()`.
+SDK 0.21.0 preserves the default board and adds the complete advanced contracts:
+
+```ts
+const signals = await client.edgeHunter.get({ view: "signals", category: "Soccer", min_grade: "A", limit: 20 });
+if (signals.object === "list") console.log(signals.view, signals.data, signals.next_cursor);
+
+const observations = await client.edgeHunter.observations({ cohort: "in_play", limit: 20 });
+if (observations.object === "list") console.log(observations.snapshot_as_of, observations.degraded, observations.funnel);
+
+const unchanged = await client.edgeHunter.getConditional(
+  { view: "observations", cohort: "in_play" },
+  { headers: { "If-None-Match": observations.meta.etag ?? "" } },
+);
+if (unchanged.object === "not_modified") console.log("Unchanged snapshot");
+```
+
+`view: "signals"` returns full ranked records, nullable `token_id`, snapshot clocks,
+holder/directional analytics, category evidence and provenance. It accepts `category`,
+`min_grade` (S/A/B, default B), `horizon_hours` (default 12, clamp 1..48), `limit`
+(default 20, clamp 1..100) and `cursor`. Grade floor requires a holder at that grade or better;
+it does not remove other holders. `signals()` is a convenience for the same mode.
+
+`view: "observations"` requires `cohort` (`wider_holder`, `in_play`, `emerging_pile`)
+and accepts `category`, `limit` and `cursor`. Records preserve verified token IDs,
+midpoint `backed_price` marks, observation/holder clocks, provider/directional status,
+and completeness. The envelope retains `snapshot_as_of`, `degraded` and all per-sport
+funnel diagnostics. Price marks are not wallet entry costs; volume is shares.
+In-play reuse is capped at 30 seconds and fails closed without fresh source evidence.
+
+Literal view queries have distinct result types, including on empty pages. Advanced
+responses add `view: "signals" | "observations"` beside `object: "list"`. Both advanced
+views support ETag/304 and private revalidation. All public views read warmed generations only;
+missing/stale readiness returns 503 `read_model_warming` with `Retry-After: 5`
+without running holder/provider computation in the request. `getConditional()`
+accepts advanced views only. Parameters for another view return 400, and a refreshed
+snapshot expires its cursors. Start a new cursor walk when migrating from retired URLs.
+The shared `list()`, `paginate()`, `paginatePages()` and `collect()` helpers accept
+Edge Hunter only with an explicit advanced view and preserve the corresponding record
+and envelope types:
+
+```ts
+for await (const page of paginatePages(client, "getEdgeHunter", {
+  query: { view: "observations", cohort: "wider_holder", limit: 100 },
+  maxPages: 2,
+})) console.log(page.view, page.funnel, page.data);
+```
+
+SDK 0.22.0 adds common selections to every Edge Hunter view:
+
+```ts
+const nfl = await client.edgeHunter.get({ kind: "sports", leagues: ["nfl"], limit: 10 });
+if (nfl.object === "edge_hunter") {
+  console.log(nfl.selection, nfl.data.rows.map(row => row.market_context));
+}
+const selectedSignals = await client.edgeHunter.signals({
+  sports: ["Soccer", "Football"], market_types: ["moneyline"], min_grade: "A", limit: 20,
+});
+const selectedObservations = await client.edgeHunter.observations({
+  cohort: "in_play", kind: "esports", leagues: ["cs2", "lol"], limit: 20,
+});
+```
+
+| Selection | Meaning |
+| --- | --- |
+| `kind` | `sports` or `esports`; omit for both |
+| `sports` | Canonical sport buckets, including `Football`, `Soccer`, `Esports` and `Table Tennis`; case-insensitive |
+| `leagues` | Machine/provider league identities such as `nfl`, `epl`, `cs2` and `lol`; known wire/tag aliases normalize |
+| `market_types` | Exact provider `sports_market_type` values from `market_context.market_type` |
+| `condition_ids` | Exact markets by raw provider ID or `mkt_` alias |
+| `event_slugs` / `series_slugs` | Exact provider event/series identities from the row and `market_context.series_slug` |
+| `category` | Legacy canonical bucket alias: `NFL` selects all Football; use `leagues: ["nfl"]` for NFL only |
+
+Lists match OR within an axis and AND across axes. Each array must contain 1..100
+supplied values before server normalization and deduplication; empty SDK arrays
+fail before HTTP. The SDK serializes repeated bare query names, and the server
+also accepts CSV inside a value. Market types and event/series slugs are trimmed
+exact case-sensitive strings. Unknown canonical sport names are invalid; unknown
+provider identities or market IDs can yield an empty selected collection.
+
+A selected 200 response adds top-level `selection` with only requested normalized
+axes. Blank `category` retains omission behavior. Selected SDK reads always send
+`X-Query-Validation: strict`, even if `strictQuery: false` was supplied, and refuse
+responses missing their echo so an older serving instance cannot silently ignore
+new filters. Generic `call()`, `list()` and pagination use the same protection.
+Advanced cursors and ETags bind the normalized selection; restart at page one
+when changing it.
+
+Every row adds required nullable `market_context` with required nullable `league`,
+`series_slug`, `market_type` and `metadata_updated_at`. Discover exact selectors
+from those frozen facts. The clock is local `market_canonical.updated_at`, not a
+provider observation time. Unselected legacy cache generations may carry
+`market_context: null`; selected reads require a ready frozen sidecar and return
+503 warming if it is absent. Missing selected metadata excludes rows. Observation
+`funnel` remains source-generation/category accounting rather than a league/type/ID
+request-input census.
 
 ### Beyond the JSON envelope
 
@@ -350,7 +445,7 @@ for await (const trade of paginate(client, "listWhaleTrades", {
 }
 ```
 
-The loop ends when a page says `has_more: false`, whatever its `next_cursor` says. A page that says `has_more: true` with no usable `next_cursor`, or one whose `next_cursor` repeats a cursor the walk already requested, is a broken response rather than the end of the collection: the walk throws `PaginationError` (`reason` `missing_cursor` or `repeated_cursor`) before yielding that page and before any duplicate request, with the received `page` on the error so its data is not lost. The last 1,024 cursors are remembered for the repeat check (`CURSOR_HISTORY_LIMIT`), which keeps a long walk's memory flat. A list response whose `has_more` is not a boolean or whose `next_cursor` is not a string throws `InvalidResponseError`.
+The loop ends when a page says `has_more: false`, whatever its `next_cursor` says. A page that says `has_more: true` with no usable `next_cursor`, or one whose `next_cursor` repeats a cursor the walk already requested, is a broken response rather than the end of the collection: the walk throws `PaginationError` (`reason` `missing_cursor` or `repeated_cursor`) before yielding that page and before any duplicate request, with the received `page` on the error so its data is not lost. The last 1,024 cursors are remembered for the repeat check (`CURSOR_HISTORY_LIMIT`), which keeps a long walk's memory flat. A list response whose `has_more` is not a boolean or whose `next_cursor` is neither a string, null nor omitted throws `InvalidResponseError`. A null terminal cursor is preserved for Edge Hunter observations.
 
 `maxPages` caps fetches and is checked before any request: a positive integer or `Infinity`; `0`, a negative, fractional or `NaN` value throws `RangeError`. Reaching it is your choice, not exhaustion. Pass a `progress` object to tell the two apart and keep the continuation:
 

package/dist/client.d.ts

@@ -19,7 +19,7 @@
  *  - 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";
+import type { OperationBody, OperationData, OperationPath, OperationQuery, OperationResponse, ResponseMeta, EdgeHunterBoardResponse, EdgeHunterSignalsResponse, EdgeHunterObservationsResponse } from "./schema.js";
 /**
  * The envelope `meta` as THIS client hands it to a caller: everything the
  * contract declares (`ResponseMeta`), plus `etag`.
@@ -852,8 +852,29 @@ export interface CategorySkillStatusCounts {
 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 accepted by the Max-only Edge Hunter board. */
-export type EdgeHunterParams = OperationQuery["getEdgeHunter"];
+/** Optional selection axes shared by every Max-only Edge Hunter view. */
+export type EdgeHunterSelectionParams = Pick<OperationQuery["getEdgeHunter"], "kind" | "sports" | "leagues" | "market_types" | "condition_ids" | "event_slugs" | "series_slugs" | "category">;
+/** Quoted board selection, grade floor and cap; existing defaults remain compatible. */
+export type EdgeHunterBoardParams = EdgeHunterSelectionParams & Pick<OperationQuery["getEdgeHunter"], "horizon_hours" | "min_grade" | "limit"> & {
+    view?: "board";
+};
+/** Full ranked records with category, grade and horizon projection before pagination. */
+export type EdgeHunterSignalsParams = EdgeHunterSelectionParams & Pick<OperationQuery["getEdgeHunter"], "limit" | "cursor" | "horizon_hours" | "min_grade"> & {
+    view: "signals";
+};
+/** Full observation evidence; cohort is required, including for empty pages. */
+export type EdgeHunterObservationsParams = EdgeHunterSelectionParams & Pick<OperationQuery["getEdgeHunter"], "limit" | "cursor"> & {
+    view: "observations";
+    cohort: NonNullable<OperationQuery["getEdgeHunter"]["cohort"]>;
+};
+export type EdgeHunterAdvancedParams = EdgeHunterSignalsParams | EdgeHunterObservationsParams;
+export type EdgeHunterParams = EdgeHunterBoardParams | EdgeHunterAdvancedParams;
+export type EdgeHunterBoardResult = ClientEnvelope<EdgeHunterBoardResponse> | ApiNotModifiedResponse;
+export type EdgeHunterSignalsResult = ClientEnvelope<EdgeHunterSignalsResponse> | ApiNotModifiedResponse;
+export type EdgeHunterObservationsResult = ClientEnvelope<EdgeHunterObservationsResponse> | ApiNotModifiedResponse;
+export type EdgeHunterAdvancedResult = EdgeHunterSignalsResult | EdgeHunterObservationsResult;
+/** Full advanced collection envelope for a literal view; excludes conditional 304 results. */
+export type EdgeHunterCollection<P extends EdgeHunterAdvancedParams> = P extends EdgeHunterSignalsParams ? Exclude<EdgeHunterSignalsResult, ApiNotModifiedResponse> : Exclude<EdgeHunterObservationsResult, ApiNotModifiedResponse>;
 /** Public wallet facts associated with a recorded pick. */
 export interface PickQualifyingExpert {
     address: string;
@@ -935,9 +956,13 @@ export type OperationMeta<K extends ApiOperationId> = OperationResponse[K] exten
  * 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>>;
-};
+type ClientEnvelope<T> = T extends {
+    meta: infer M;
+} ? Omit<T, "meta"> & {
+    meta: ClientMeta<M>;
+} : never;
+/** Distribute over response variants so view-specific pagination and evidence stay typed. */
+export type OperationEnvelope<K extends EnvelopeOperationId> = ClientEnvelope<OperationResponse[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`. */
@@ -989,6 +1014,8 @@ export type OperationOptionsArgs<K extends ApiOperationId, O> = OperationRequire
  * parameter before any request.
  */
 export type RuntimeOperationId<I extends ApiOperationId> = I & (ApiOperationId extends I ? unknown : OptionalInputOperationId);
+/** A literal Edge Hunter list call must select an advanced view; runtime-chosen ids stay available. */
+export type RuntimeListOperationId<I extends ApiOperationId> = RuntimeOperationId<I> & ("getEdgeHunter" extends I ? ApiOperationId extends I ? unknown : never : unknown);
 /** 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. */
@@ -1135,14 +1162,31 @@ export declare class OxinsiderApiClient {
     private readonly fetchImpl;
     private readonly timeoutMs;
     private readonly maxRetries;
-    /** Full experimental Edge Hunter board. Requires a Max credential. */
+    /** Max-only Edge Hunter board and full ranked/observation collection views. */
     readonly edgeHunter: {
-        get: (params?: EdgeHunterParams, options?: ConvenienceOptions) => Promise<OperationResult<"getEdgeHunter">>;
+        get: {
+            (params?: EdgeHunterBoardParams, options?: ConvenienceOptions): Promise<EdgeHunterBoardResult>;
+            (params: EdgeHunterSignalsParams, options?: ConvenienceOptions): Promise<EdgeHunterSignalsResult>;
+            (params: EdgeHunterObservationsParams, options?: ConvenienceOptions): Promise<EdgeHunterObservationsResult>;
+            (params: EdgeHunterParams, options?: ConvenienceOptions): Promise<OperationResult<"getEdgeHunter">>;
+        };
+        /** Conditional reads are supported only by the advanced snapshot views. */
+        getConditional: {
+            (params: EdgeHunterSignalsParams, options?: ConvenienceOptions): Promise<EdgeHunterSignalsResult>;
+            (params: EdgeHunterObservationsParams, options?: ConvenienceOptions): Promise<EdgeHunterObservationsResult>;
+            (params: EdgeHunterAdvancedParams, options?: ConvenienceOptions): Promise<EdgeHunterAdvancedResult>;
+        };
+        signals: (params?: Omit<EdgeHunterSignalsParams, "view">, options?: ConvenienceOptions) => Promise<EdgeHunterSignalsResult>;
+        observations: (params: Omit<EdgeHunterObservationsParams, "view">, options?: ConvenienceOptions) => Promise<EdgeHunterObservationsResult>;
     };
+    private getEdgeHunter;
+    private getAdvancedEdgeHunter;
     /** Polymarket combo fills, live count, and one combo's observed details. */
     readonly combos: {
         /** Recent pages use next_cursor; ranked pages use next_offset. */
-        fills: (params?: ComboFillsParams, options?: ConvenienceOptions) => Promise<OperationEnvelope<"listComboFills">>;
+        fills: (params?: ComboFillsParams, options?: ConvenienceOptions) => Promise<Omit<import("./schema.js").ComboFillsResponse, "meta"> & {
+            meta: ClientMeta<ResponseMeta>;
+        }>;
         summary: (options?: ConvenienceOptions) => Promise<OperationResult<"getCombosSummary">>;
         get: (conditionId: OperationPath["getCombo"]["condition_id"], options?: ConvenienceOptions) => Promise<OperationResult<"getCombo">>;
     };
@@ -1282,9 +1326,12 @@ export declare class OxinsiderApiClient {
      * `facets` or `totals`). Use `paginate()` (in `pagination.ts`) to
      * auto-follow `next_cursor`.
      */
+    list<P extends EdgeHunterAdvancedParams>(operationId: "getEdgeHunter", options: ConvenienceOptions & {
+        query: P;
+    }): Promise<EdgeHunterCollection<P>>;
     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>>;
+    list<T = unknown, I extends ApiOperationId = ApiOperationId>(operationId: RuntimeListOperationId<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">>;
     /**
@@ -1338,9 +1385,37 @@ export declare class OxinsiderApiClient {
      * `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">>;
+    listLeaderboard(params?: LeaderboardListParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listLeaderboard"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
+    listTrendingWallets(params?: TrendingWalletsParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listTrendingWallets"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
+    listLargeTrades(params?: LargeTradeListParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listLargeTrades"];
+        data_quality: import("./schema.js").DataQuality;
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /**
      * Typed conditional-read variant of {@link listLargeTrades}, for polling
      * (#18507). Returns the list envelope on 200 or the typed `not_modified`
@@ -1349,24 +1424,96 @@ export declare class OxinsiderApiClient {
      * 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">>;
+    listLargeTradeHistory(params?: LargeTradeHistoryParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listLargeTradeHistory"];
+        data_quality: import("./schema.js").DataQuality;
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: import("./schema.js").LargeTradeHistoryMeta;
+    }, "meta"> & {
+        meta: ClientMeta<import("./schema.js").LargeTradeHistoryMeta>;
+    }>;
     /** @deprecated Use {@link listLargeTrades} (#16304); calls the deprecated `/api/v1/whale-trades`. */
-    listWhaleTrades(params?: WhaleTradeListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listWhaleTrades">>;
+    listWhaleTrades(params?: WhaleTradeListParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listWhaleTrades"];
+        data_quality: import("./schema.js").DataQuality;
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /** @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">>;
+    listWhaleTradeHistory(params?: WhaleTradeHistoryParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listWhaleTradeHistory"];
+        data_quality: import("./schema.js").DataQuality;
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: import("./schema.js").LargeTradeHistoryMeta;
+    }, "meta"> & {
+        meta: ClientMeta<import("./schema.js").LargeTradeHistoryMeta>;
+    }>;
+    listPositions(params?: PositionsListParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listPositions"];
+        data_quality: import("./schema.js").DataQuality;
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        snapshot?: {
+            as_of: string;
+            expires_at: string;
+            row_count: number;
+        };
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
+    listLargePositions(params?: LargePositionsListParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listLargePositions"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /**
      * 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">>;
+    listSharpMoneyFlows(params?: SharpMoneyFlowsParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listSharpMoneyFlows"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /**
      * @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">>;
+    listSmartMoneyFlows(params?: OperationQuery["listSmartMoneyFlows"], options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listSmartMoneyFlows"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /**
      * 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
@@ -1375,7 +1522,17 @@ export declare class OxinsiderApiClient {
      * 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">>;
+    listGames(params?: GamesListParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listGames"];
+        has_more: boolean;
+        next_cursor?: string;
+        as_of: string;
+        coverage: import("./schema.js").GamesCoverage;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /**
      * Read one game by its `event_slug`, the identity the `live_sports_updated`
      * webhook pulse carries. A slug outside the published coverage returns 404.
@@ -1383,11 +1540,41 @@ export declare class OxinsiderApiClient {
     getGame(eventSlug: OperationPath["getGame"]["event_slug"], options?: ConvenienceOptions): Promise<OperationResult<"getGame">>;
     searchMarkets(q: OperationQuery["searchMarkets"]["q"], options?: ConvenienceOptions & {
         query?: Omit<OperationQuery["searchMarkets"], "q">;
-    }): Promise<OperationEnvelope<"searchMarkets">>;
+    }): Promise<Omit<{
+        object: "list";
+        data: OperationData["searchMarkets"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     searchContent(q: OperationQuery["searchContent"]["q"], options?: ConvenienceOptions & {
         query?: Omit<OperationQuery["searchContent"], "q">;
-    }): Promise<OperationEnvelope<"searchContent">>;
-    exploreMarkets(params?: ExploreMarketsParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"exploreMarkets">>;
+    }): Promise<Omit<{
+        object: "list";
+        data: OperationData["searchContent"];
+        has_more: false;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
+    exploreMarkets(params?: ExploreMarketsParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["exploreMarkets"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        facets: import("./schema.js").ExploreFacets;
+        meta: ResponseMeta;
+        computed_at?: string;
+        fresh_for_seconds?: number;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /** 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">>;
     /**
@@ -1405,7 +1592,19 @@ export declare class OxinsiderApiClient {
      * 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">>;
+    getMarketHolders(conditionId: OperationPath["getMarketHolders"]["condition_id"], params?: OperationQuery["getMarketHolders"], options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["getMarketHolders"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        market: import("./schema.js").MarketHoldersMarket;
+        scan: import("./schema.js").MarketHoldersScan;
+        totals: import("./schema.js").MarketHoldersTotals;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /**
      * Fetch bucketed OHLC candles for a market's outcome tokens.
      * Resolution defaults to the server default; pass `params.resolution` as
@@ -1420,7 +1619,16 @@ export declare class OxinsiderApiClient {
      */
     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">>;
+    listSuspiciousTrades(params?: SuspiciousTradesListParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listSuspiciousTrades"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /**
      * @deprecated Use `getSuspiciousTrade()`; renamed in #16301. This method
      * keeps calling the deprecated `GET /api/v1/insider-radar/{id}`, which stays
@@ -1434,7 +1642,16 @@ export declare class OxinsiderApiClient {
      * with no retirement date and answers with `Deprecation` plus a `Link
      * rel="successor-version"` header.
      */
-    listInsiderRadar(params?: InsiderRadarListParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listInsiderRadar">>;
+    listInsiderRadar(params?: InsiderRadarListParams, options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listInsiderRadar"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     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">>;
@@ -1451,7 +1668,16 @@ export declare class OxinsiderApiClient {
      * 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">>;
+    listWebhooks(options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listWebhooks"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     getWebhook(id: OperationPath["getWebhook"]["id"], options?: ConvenienceOptions): Promise<OperationResult<"getWebhook">>;
     createWebhook(body: OperationBody["createWebhook"], options?: ConvenienceOptions): Promise<OperationResult<"createWebhook">>;
     /** Admit durable consent; 202 acknowledges admission, not activation. */
@@ -1464,9 +1690,27 @@ export declare class OxinsiderApiClient {
      * Fetch the self-describing webhook event catalog (each entry's `id`,
      * description, payload shape, and active/dormant status).
      */
-    listWebhookEvents(options?: ConvenienceOptions): Promise<OperationEnvelope<"listWebhookEvents">>;
+    listWebhookEvents(options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listWebhookEvents"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /** List delivery attempts for one webhook endpoint (Stripe-style list). */
-    listWebhookDeliveries(webhookId: OperationPath["listWebhookDeliveries"]["id"], params?: OperationQuery["listWebhookDeliveries"], options?: ConvenienceOptions): Promise<OperationEnvelope<"listWebhookDeliveries">>;
+    listWebhookDeliveries(webhookId: OperationPath["listWebhookDeliveries"]["id"], params?: OperationQuery["listWebhookDeliveries"], options?: ConvenienceOptions): Promise<Omit<{
+        object: "list";
+        data: OperationData["listWebhookDeliveries"];
+        has_more: boolean;
+        next_cursor?: string;
+        total?: number;
+        meta: ResponseMeta;
+    }, "meta"> & {
+        meta: ClientMeta<ResponseMeta>;
+    }>;
     /**
      * Requeue one `dead_letter` delivery with a fresh attempt budget and return
      * the delivery row. Re-enabling a disabled endpoint resends nothing, so this