@0xinsider/sdk 0.19.0 → 0.21.0

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`.
@@ -235,23 +235,8 @@ export declare const API_CLIENT_OPERATIONS: readonly [{
     readonly auth: "bearer";
 }, {
     readonly method: "GET";
-    readonly path: "/api/v1/sports/pre-game-sides";
-    readonly operationId: "listPreGameSides";
-    readonly auth: "bearer";
-}, {
-    readonly method: "GET";
-    readonly path: "/api/v1/sports/pre-game-side-observations";
-    readonly operationId: "listPreGameSideObservations";
-    readonly auth: "bearer";
-}, {
-    readonly method: "GET";
-    readonly path: "/api/v1/sports-edge-signals";
-    readonly operationId: "listSportsEdgeSignals";
-    readonly auth: "bearer";
-}, {
-    readonly method: "GET";
-    readonly path: "/api/v1/sports-edge-observations";
-    readonly operationId: "listSportsEdgeObservations";
+    readonly path: "/api/v1/edge-hunter";
+    readonly operationId: "getEdgeHunter";
     readonly auth: "bearer";
 }, {
     readonly method: "GET";
@@ -615,6 +600,26 @@ export declare const REDIRECT_OPERATIONS: readonly [{
  * accounted for here, so "unsupported" is always a stated decision.
  */
 export declare const UNSUPPORTED_OPERATIONS: readonly [{
+    readonly method: "GET";
+    readonly path: "/api/v1/sports/pre-game-sides";
+    readonly operationId: "listPreGameSides";
+    readonly reason: "Retired permanently: this path returns 410 endpoint_retired. Use edgeHunter.get() with a Max credential.";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/sports/pre-game-side-observations";
+    readonly operationId: "listPreGameSideObservations";
+    readonly reason: "Retired permanently: this path returns 410 endpoint_retired. Use edgeHunter.get() with a Max credential.";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/sports-edge-signals";
+    readonly operationId: "listSportsEdgeSignals";
+    readonly reason: "Retired permanently: this path returns 410 endpoint_retired. Use edgeHunter.get() with a Max credential.";
+}, {
+    readonly method: "GET";
+    readonly path: "/api/v1/sports-edge-observations";
+    readonly operationId: "listSportsEdgeObservations";
+    readonly reason: "Retired permanently: this path returns 410 endpoint_retired. Use edgeHunter.get() with a Max credential.";
+}, {
     readonly method: "GET";
     readonly path: "/api/v1/mcp";
     readonly operationId: "openMcpEventStream";
@@ -847,43 +852,27 @@ 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 of `GET /api/v1/sports/pre-game-sides` (#16310). */
-export type PreGameSidesParams = OperationQuery["listPreGameSides"];
-/** @deprecated Use {@link PreGameSidesParams} (#16310). */
-export type SportsEdgeSignalsParams = PreGameSidesParams;
-/** Observation cohorts exposed by `listPreGameSideObservations`. */
-export type SportsEdgeObservationCohort = "wider_holder" | "in_play" | "emerging_pile";
-/** Source of the provider holder snapshot used to build an observation. */
-export type SportsEdgeObservationProviderSource = "cached" | "live";
-/** Why a sport's upcoming-board source is (un)available in the funnel report. */
-export type SportsEdgeObservationBoardUpcomingStatus = "unknown" | "not_configured" | "available" | "capacity_limited" | "source_unavailable" | "cold_unavailable" | "deadline_unavailable";
-/** Scope attribution for an unavailable upcoming-board union. */
-export type SportsEdgeObservationBoardUnavailableScope = "category" | "nfl" | "cfb" | "nba" | "wnba" | "nhl" | "mls" | "valorant" | "league-of-legends" | "counter-strike-2" | "dota-2" | "registry" | "union" | "wave";
-/** Truthful state of the cross-market directional read. */
-export type SportsEdgeObservationDirectionalStatus = "available" | "unknown_ungrouped" | "unknown_stale" | "unavailable";
-/**
- * Provider binary-column selector for observation markets: 0 selects
- * outcome_yes/token_id_yes; 1 selects outcome_no/token_id_no. Use piled_side,
- * not this index, for participant identity.
- */
-export type SportsEdgeObservationOutcomeIndex = 0 | 1;
-/** Closed grade vocabulary for the best holder grade on an observation. */
-export type SportsEdgeObservationTopGrade = "S" | "A" | "B";
-/** Canonical sports emitted by observation responses. */
-export type SportsEdgeObservationSport = "Basketball" | "Football" | "Baseball" | "Hockey" | "MMA" | "Boxing" | "Soccer" | "Cricket" | "Golf" | "Tennis" | "Esports" | "Racing" | "Table Tennis" | "Pickleball";
-/**
- * Full list response, including the observation snapshot and accountable
- * funnel: the operation's own envelope (#16136). `degraded` is the
- * snapshot-wide verdict; fully accounted `capacity_limited` rows alone do
- * not set it.
- */
-export type PreGameSideObservationsResponse = OperationEnvelope<"listPreGameSideObservations">;
-/** @deprecated Use {@link PreGameSideObservationsResponse} (#16310). */
-export type SportsEdgeObservationsResponse = PreGameSideObservationsResponse;
-/** Query parameters of `GET /api/v1/sports/pre-game-side-observations` (#16310). */
-export type PreGameSideObservationsParams = OperationQuery["listPreGameSideObservations"];
-/** @deprecated Use {@link PreGameSideObservationsParams} (#16310). */
-export type SportsEdgeObservationsParams = PreGameSideObservationsParams;
+/** The unchanged quoted board; advanced-only parameters are unavailable here. */
+export type EdgeHunterBoardParams = Pick<OperationQuery["getEdgeHunter"], "horizon_hours"> & {
+    view?: "board";
+};
+/** Full ranked records with category, grade and horizon projection before pagination. */
+export type EdgeHunterSignalsParams = Pick<OperationQuery["getEdgeHunter"], "category" | "limit" | "cursor" | "horizon_hours" | "min_grade"> & {
+    view: "signals";
+};
+/** Full observation evidence; cohort is required, including for empty pages. */
+export type EdgeHunterObservationsParams = Pick<OperationQuery["getEdgeHunter"], "category" | "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;
@@ -965,9 +954,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`. */
@@ -1019,6 +1012,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. */
@@ -1165,10 +1160,31 @@ export declare class OxinsiderApiClient {
     private readonly fetchImpl;
     private readonly timeoutMs;
     private readonly maxRetries;
+    /** Max-only Edge Hunter board and full ranked/observation collection views. */
+    readonly edgeHunter: {
+        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">>;
     };
@@ -1308,9 +1324,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">>;
     /**
@@ -1364,9 +1383,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`
@@ -1375,24 +1422,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
@@ -1401,64 +1520,59 @@ 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.
      */
     getGame(eventSlug: OperationPath["getGame"]["event_slug"], options?: ConvenienceOptions): Promise<OperationResult<"getGame">>;
-    /**
-     * List upcoming games and their public market-side data.
-     * Rows carry `side`, `ranked_at`,
-     * `backing_score` and `side_share`; the older `piled_side`,
-     * `signal_created_at`, `conviction_score` and `smart_score` keys carry the
-     * same values and stay on the wire.
-     */
-    listPreGameSides(params?: PreGameSidesParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listPreGameSides">>;
-    /**
-     * @deprecated Use {@link listPreGameSides} (#16310). Kept live; it calls the
-     * deprecated `/api/v1/sports-edge-signals` path, which answers with
-     * `Deprecation` and successor `Link` headers and the same body.
-     */
-    listSportsEdgeSignals(params?: SportsEdgeSignalsParams, options?: ConvenienceOptions): Promise<OperationEnvelope<"listSportsEdgeSignals">>;
-    /**
-     * Read an explicitly observation-only sports cohort and its accountable
-     * per-sport funnel. This surface is isolated from the funded signals route.
-     * Healthy wider-holder and emerging-pile snapshots may be served for about
-     * 180 seconds; in-play cached snapshots are capped at about 30 seconds and
-     * stale provider live-board evidence fails closed. emerging-pile is an
-     * additive wider-holder projection, not an arrival-history or independent
-     * denominator view.
-     */
-    listPreGameSideObservations(params: PreGameSideObservationsParams, options?: ConvenienceOptions): Promise<PreGameSideObservationsResponse>;
-    /**
-     * @deprecated Use {@link listPreGameSideObservations} (#16310). Kept live; it
-     * calls the deprecated `/api/v1/sports-edge-observations` path, which answers
-     * with `Deprecation` and successor `Link` headers and the same body.
-     */
-    listSportsEdgeObservations(params: SportsEdgeObservationsParams, options?: ConvenienceOptions): Promise<SportsEdgeObservationsResponse>;
-    /**
-     * Typed conditional-read variant of {@link listSportsEdgeObservations}.
-     * Returns the full observation response on 200 or a typed `not_modified`
-     * envelope on 304 instead of routing the latter through generic `call()`.
-     * The endpoint emits a weak semantic ETag over the stable response payload;
-     * request-specific `meta` is excluded. For emerging-pile, the opaque
-     * projection cutoff inside `next_cursor` is excluded while its stable page
-     * position remains covered.
-     */
-    listPreGameSideObservationsConditional(params: PreGameSideObservationsParams, options?: ConvenienceOptions): Promise<PreGameSideObservationsResponse | ApiNotModifiedResponse>;
-    /**
-     * @deprecated Use {@link listPreGameSideObservationsConditional} (#16310).
-     * Kept live on the deprecated `/api/v1/sports-edge-observations` path.
-     */
-    listSportsEdgeObservationsConditional(params: SportsEdgeObservationsParams, options?: ConvenienceOptions): Promise<SportsEdgeObservationsResponse | ApiNotModifiedResponse>;
     searchMarkets(q: OperationQuery["searchMarkets"]["q"], options?: ConvenienceOptions & {
         query?: Omit<OperationQuery["searchMarkets"], "q">;
-    }): Promise<OperationEnvelope<"searchMarkets">>;
+    }): 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">>;
     /**
@@ -1476,7 +1590,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
@@ -1491,7 +1617,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
@@ -1505,7 +1640,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">>;
@@ -1522,7 +1666,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. */
@@ -1535,9 +1688,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