@predictorsdk/client 0.14.0 → 0.15.1

package/dist/Client.d.ts

@@ -25,7 +25,7 @@ export declare class PredictorSDKClient {
     getPlans(requestOptions?: PredictorSDKClient.RequestOptions): core.HttpResponsePromise<PredictorSDK.PlansResponse>;
     private __getPlans;
     /**
-     * Find cross-platform market matches for sports events. Coverage is NBA, WNBA, NHL, and MLB; `canonical_events[].league` names the league and is the first segment of the canonical `event_id`. When called without parameters, returns all currently matched sports markets with cursor-based pagination (default `limit=25`, max `100`). Provide a canonical event key, Kalshi event ticker, Polymarket slug, Predict market ID, or SX Bet market ID to look up a specific event — lookups return the full match immediately and skip pagination. Every platform row includes its provider-native `event_id` for use with `GET /v1/events/{event_id}`; pass that row's `platform` value as the events endpoint's `platform` query parameter, which is required to disambiguate Predict and AlphaArcade identifiers.
+     * Find cross-platform market matches for sports events. Coverage is NBA, WNBA, NHL, MLB, and NFL; `canonical_events[].league` names the league and is the first segment of the canonical `event_id`. When called without parameters, returns all currently matched sports markets with cursor-based pagination (default `limit=25`, max `100`) — games whose date has passed are excluded unless you ask for them with `include_settled=true`. Provide a canonical event key, Kalshi event ticker, Polymarket slug, Predict market ID, or SX Bet market ID to look up a specific event — lookups return the full match immediately and skip pagination. Every platform row includes its provider-native `event_id` for use with `GET /v1/events/{event_id}`; pass that row's `platform` value as the events endpoint's `platform` query parameter, which is required to disambiguate Predict and AlphaArcade identifiers.
      *
      * @param {PredictorSDK.GetSportsMatchingMarketsRequest} request
      * @param {PredictorSDKClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -48,6 +48,10 @@ export declare class PredictorSDKClient {
     /**
      * Returns a paginated list of unified markets from all supported prediction market providers. Uses cursor-based pagination with default `limit=25`, max `100`.
      *
+     * Providers are walked in a fixed sequence, so without a filter the first pages are all Kalshi. Narrow the traversal with `provider` and/or `category`; both are membership filters on the same immutable catalog snapshot, both compose, and `pagination.total` always counts the filtered set rather than the whole catalog.
+     *
+     * This endpoint reads a stored snapshot rather than calling the venues, so the rows are as old as the last ingestion crawl, not as old as the request. `snapshot.observed_at` reports that age and is stable across a cursor traversal.
+     *
      * @param {PredictorSDK.GetMarketsRequest} request
      * @param {PredictorSDKClient.RequestOptions} requestOptions - Request-specific configuration.
      *
@@ -86,11 +90,19 @@ export declare class PredictorSDKClient {
     getCategories(requestOptions?: PredictorSDKClient.RequestOptions): core.HttpResponsePromise<PredictorSDK.CategoriesResponse>;
     private __getCategories;
     /**
-     * Returns a single market across the six supported platforms (Kalshi, Polymarket, Predict, SX Bet, Hyperliquid, AlphaArcade). The `market_id` is either the composite form returned by `GET /v1/markets` (`{provider}:{native_id}`, e.g. `kalshi:KXNBA-26-SAS`) or the platform-native identifier. Composite IDs dispatch unambiguously by prefix. Native IDs are routed by format inference: Kalshi tickers match the all-caps-with-hyphens shape (`KX…-…`); SX Bet hashes match `0x` + 64 hex characters; numeric ids and kebab-case slugs are shared shape between Polymarket and Predict and probe Polymarket first, falling back to Predict on 404. Hyperliquid integer outcome ids collide with Polymarket/Predict numeric ids and are deliberately not inferred — route them via the composite form (`hyperliquid:<id>`) or `?platform=hyperliquid` (alias `hl`). AlphaArcade market ids are ULIDs (26-char Crockford base32, e.g. `01KQV5TQ9CE20WPEVJZX2ETNQD`); like Hyperliquid they are not inferred in v1 — route them via the composite form (`alpha-arcade:<ulid>`) or `?platform=alpha-arcade` (alias `aa`). Pass `?platform=` explicitly to skip the probe.
+     * Returns a single market across the six supported platforms (Kalshi, Polymarket, Predict, SX Bet, Hyperliquid, AlphaArcade). The `market_id` is either the composite form returned by `GET /v1/markets` (`{provider}:{native_id}`, e.g. `kalshi:KXNBA-27-SAS`) or the platform-native identifier. Composite IDs dispatch unambiguously by prefix. Native IDs are routed by format inference: Kalshi tickers match the all-caps-with-hyphens shape (`KX…-…`); SX Bet hashes match `0x` + 64 hex characters.
+     *
+     * **A bare numeric id or kebab-case slug does not name its platform.** Polymarket and Predict share both shapes, so when `?platform=` is omitted the service probes every candidate and answers only if exactly one of them holds that identifier. If two do, the identifier names two different real markets and the request fails with `409` listing both — it does not pick one. Retry with `?platform=` or the composite form. Hyperliquid integer outcome ids collide with Polymarket/Predict numeric ids and are deliberately not inferred — route them via the composite form (`hyperliquid:<id>`) or `?platform=hyperliquid` (alias `hl`). AlphaArcade market ids are ULIDs (26-char Crockford base32, e.g. `01K0HQE3CEM2T2RDRWSCJ3V647`); like Hyperliquid they are not inferred in v1 — route them via the composite form (`alpha-arcade:<ulid>`) or `?platform=alpha-arcade` (alias `aa`).
+     *
+     * **If you already know the platform, always say so.** Every listing that hands you an identifier also hands you its platform, so the composite form — which `GET /v1/markets` returns natively in `data[].id` — or `?platform={row.platform}` costs nothing, skips the probe, and cannot 409. It is also strictly more available: the probe has to reach both candidates to prove there is no collision, so it fails when either is having an outage, while a named platform only depends on that one.
      *
      * Identity fields (id/provider/provider_id/title/status/ outcomes[].name) are strict-universal: every platform's single-market endpoint exposes them natively without a second fetch. close timestamps and parent event ids remain omitted (not nullable) — Predict's close time lives on the parent category and Polymarket's market record carries no event id.
      *
-     * The pricing tier adds per-outcome quotes (`price`/`bid`/`ask`/ `last` as 0–1 probability numbers — price IS the implied probability), a `pricing` envelope (`availability`/`scale`/ `source`/`as_of`/`neg_risk`), and market-level aggregates (`liquidity_usd`, `volume_24h_usd`, `volume_total_usd`, plus Kalshi contract-count mirrors and `open_interest`). Kalshi/ Polymarket/Predict quotes come from the same record the identity fetch returns (`pricing.source=market_record`). SX Bet, Hyperliquid, and AlphaArcade carry no pricing on the market record, so the server makes one bounded second fetch to the order book (`pricing.source=orderbook`) — SX Bet's best-odds endpoint, Hyperliquid's merged `l2Book`, or AlphaArcade's `get-full-orderbook` (a 4-sided YES/NO book; the second side's quotes are derived from the first by the cross-side complement, and the catalog midpoint serves as the price mark when the book is empty). On a book error the lookup still succeeds with identity intact and `pricing.availability` reflecting the marks. On timeout/error it degrades to `pricing.availability=unavailable` with identity intact — pricing failures never fail the lookup. Aggregates a platform doesn't natively expose are explicit `null` (e.g. Kalshi reports volume in contracts, so `volume_*_usd` stays null rather than fabricating a USD figure; its upstream `liquidity_dollars` field is deprecated and always zero, so `liquidity_usd` is null too).
+     * **What the pricing tier is for, and what it is not.** It reports the top of each venue's book, once, at the moment of your request. That is enough to see where a market is quoted, to compare venues, and to decide where to go and look harder. It is NOT an execution feed: there is no depth beyond the best level, no streaming, no per-outcome book on the platforms that publish only a market-wide mark, and nothing here is reserved for you — by the time you act, the level may be gone. Two limits are worth knowing before you write a strategy against it. First, `price` is a derived display number and a non-null `price` does not imply a tradeable one; read `pricing.availability` and prefer `bid`/`ask` for anything you intend to act on. Second, quote freshness is a property of the venue, not of this API — see *Bounding quote freshness* below. Route the actual order through the venue's own book.
+     *
+     * The pricing tier adds per-outcome quotes (`price`/`bid`/`ask`/ `last` as 0–1 probability numbers — price IS the implied probability), a `pricing` envelope (`availability`/`scale`/ `source`/`as_of`/`as_of_kind`/`observed_at`/`neg_risk`), and market-level aggregates (`liquidity_usd`, `volume_24h_usd`, `volume_total_usd`, plus Kalshi contract-count mirrors and `open_interest`). Kalshi/ Polymarket/Predict quotes come from the same record the identity fetch returns (`pricing.source=market_record`). SX Bet, Hyperliquid, and AlphaArcade carry no pricing on the market record, so the server makes one bounded second fetch to the order book (`pricing.source=orderbook`) — SX Bet's best-odds endpoint, Hyperliquid's merged `l2Book`, or AlphaArcade's `get-full-orderbook` (a 4-sided YES/NO book; the second side's quotes are derived from the first by the cross-side complement, and the catalog midpoint serves as the price mark when the book is empty — reported as `pricing.availability=indicative`, since a mark that outlives its book is not a quote). On a book error the lookup still succeeds with identity intact and `pricing.availability` reflecting the marks. On timeout/error it degrades to `pricing.availability=unavailable` with identity intact — pricing failures never fail the lookup. Predict publishes a per-market `spreadThreshold` — the widest bid/ask spread it counts as liquidity — and this route honours it, so a Predict book outside its own market's threshold reports `indicative` rather than lending its midpoint the authority of `live`. Aggregates a platform doesn't natively expose are explicit `null` (e.g. Kalshi reports volume in contracts, so `volume_*_usd` stays null rather than fabricating a USD figure; its upstream `liquidity_dollars` field is deprecated and always zero, so `liquidity_usd` is null too).
+     *
+     * **Bounding quote freshness.** `pricing.as_of` is the provider's own timestamp and does not mean the same thing on every platform — on Hyperliquid it moves with the order book, while on Kalshi it is a record write measured anywhere from 15 hours to 137 days old on markets reporting `status: open` with a live two-sided book. `pricing.as_of_kind` names which one you received (`quote` / `record_refresh` / `record_static` / `unknown`), so read it before applying an age bound to `as_of`; only `quote` tracks the quote closely enough to bound at all. `pricing.observed_at` is when this server read the quotes, means the same thing on every provider, and is therefore the field to bound when you need one threshold that behaves identically across platforms. It bounds the age of the read, not of the quote: this route reads the venue live per request and caches nothing, so on a `record_static` provider a fresh `observed_at` beside a day-old `as_of` is the honest description of what the venue served, and the executable price should come from that venue's own book.
      *
      * The `trading_fees` tier reports what the VENUE charges to trade this market — its own published fee parameters, normalized to one shape across all six platforms, so cross-venue cost comparison stops requiring six private formulas. Nothing here relates to PredictorSDK's subscription pricing. It is always present, and `trading_fees.availability` distinguishes published parameters from per-account rates that need your own venue credentials (SX Bet, Hyperliquid), from a venue that publishes nothing, and from a fee of genuinely zero. Only Kalshi costs extra upstream hops for it (its parameters live on the parent series plus any scheduled per-event override, all TTL-cached and bounded); those degrade to `availability: "unavailable"` rather than failing the lookup, exactly like the pricing tier. See the `MarketDetailTradingFees` schema for the formulas and for what is deliberately out of scope.
      *
@@ -102,6 +114,7 @@ export declare class PredictorSDKClient {
      * @throws {@link PredictorSDK.PaymentRequiredError}
      * @throws {@link PredictorSDK.ForbiddenError}
      * @throws {@link PredictorSDK.NotFoundError}
+     * @throws {@link PredictorSDK.ConflictError}
      * @throws {@link PredictorSDK.TooManyRequestsError}
      * @throws {@link PredictorSDK.BadGatewayError}
      * @throws {@link PredictorSDK.ServiceUnavailableError}
@@ -110,7 +123,7 @@ export declare class PredictorSDKClient {
      *
      * @example
      *     await client.getMarket({
-     *         marketId: "kalshi:KXNBA-26-SAS"
+     *         marketId: "kalshi:KXNBA-27-SAS"
      *     })
      */
     getMarket(request: PredictorSDK.GetMarketRequest, requestOptions?: PredictorSDKClient.RequestOptions): core.HttpResponsePromise<PredictorSDK.MarketDetailResponse>;
@@ -197,11 +210,15 @@ export declare class PredictorSDKClient {
     listPolymarketWalletPositions(request?: PredictorSDK.ListPolymarketWalletPositionsRequest, requestOptions?: PredictorSDKClient.RequestOptions): core.HttpResponsePromise<PredictorSDK.PolymarketPositionsResponse>;
     private __listPolymarketWalletPositions;
     /**
-     * Returns a single event and the markets nested under it on the identified platform. The `event_id` is the platform's native identifier — a Kalshi `event_ticker`, a Polymarket event slug, an SX Bet `eventId`, a Predict market identifier, a Hyperliquid question/outcome integer id, or an AlphaArcade market ULID. The `platform` is inferred from the ID format when unambiguous (`KX…` → Kalshi, `L\d+` → SX Bet). Numeric IDs and kebab-case slugs are shared shape between Polymarket and Predict; if `?platform=` is omitted in that case, the service probes Polymarket first and falls back to Predict when Polymarket returns 404. Hyperliquid integer ids also collide with those numeric ids and require `?platform=hyperliquid` (alias `hl`). AlphaArcade ULIDs are not inferred in v1 either — require `?platform=alpha-arcade` (alias `aa`). An AlphaArcade multi-choice market resolves to an event whose nested markets are its options; a binary market (or a single option id) resolves to a single-market event. Pass `?platform=` explicitly to skip the probe.
+     * Returns a single event and the markets nested under it on the identified platform. The `event_id` is the platform's native identifier — a Kalshi `event_ticker`, a Polymarket event slug, an SX Bet `eventId`, a Predict market identifier, a Hyperliquid question/outcome integer id, or an AlphaArcade market ULID. The `platform` is inferred from the ID format when unambiguous (`KX…` → Kalshi, `L\d+` → SX Bet). The composite form returned by `GET /v1/markets` (`{provider}:{native_id}`, e.g. `predict:1607914`) also dispatches unambiguously by prefix.
+     *
+     * **A bare numeric id or kebab-case slug does not name its platform.** Polymarket and Predict share both shapes, so when `?platform=` is omitted the service probes every candidate and answers only if exactly one of them holds that identifier. If two do, the identifier names two different real events and the request fails with `409` listing both — it does not pick one. Retry with `?platform=` or the composite form. Hyperliquid integer ids also collide with those numerics and require `?platform=hyperliquid` (alias `hl`). AlphaArcade ULIDs are not inferred in v1 either — require `?platform=alpha-arcade` (alias `aa`). An AlphaArcade multi-choice market resolves to an event whose nested markets are its options; a binary market (or a single option id) resolves to a single-market event.
+     *
+     * **If you already know the platform, always say so.** Every listing that hands you an identifier also hands you its platform, so `?platform={row.platform}` (or the composite form) costs nothing, skips the probe, and cannot 409. It is also strictly more available: the probe has to reach both candidates to prove there is no collision, so it fails when either is having an outage, while a named platform only depends on that one.
      *
      * Response is minimal in v0: each market is returned with its platform-native `market_id` and a human-readable `title`. Pricing, volume, status, and timestamps are intentionally deferred — they'll be added as additive fields to `EventMarket` in a later release. The endpoint mirrors the `/v1/markets` rollout pattern (titles first, fields later).
      *
-     * **Kalshi sibling fanout.** A single Kalshi sports game lives across multiple event tickers that share a game suffix — e.g. `KXMLBGAME-26MAY221840CLEPHI` holds the moneyline, `KXMLBF5TOTAL-26MAY221840CLEPHI` holds the totals, and so on. When the supplied event_ticker belongs to a sport in the sibling registry (MLB, NBA, NFL, NHL, WNBA today), this endpoint fans out across known sibling series in parallel and merges their markets into one response. Siblings that don't exist for a particular game silently drop. Siblings that error are reported under `fanout.siblings_missing`; the primary event still returns 200 in that case. Only the primary fetch failing produces a 4xx/5xx — partial fanouts never fail the request.
+     * **Kalshi sibling fanout.** A single Kalshi sports game lives across multiple event tickers that share a game suffix — e.g. `KXMLBGAME-26AUG272145AZSF` holds the moneyline, `KXMLBF5TOTAL-26AUG272145AZSF` holds the first-five-innings totals, and so on. When the supplied event_ticker belongs to a sport in the sibling registry (MLB, NBA, NFL, NHL, WNBA today), this endpoint fans out across known sibling series in parallel and merges their markets into one response. Siblings that don't exist for a particular game silently drop. Siblings that error are reported under `fanout.siblings_missing`; the primary event still returns 200 in that case. Only the primary fetch failing produces a 4xx/5xx — partial fanouts never fail the request.
      *
      * **Polymarket** events already nest the moneyline plus all spread/totals/game-level prop markets under a single event slug, so no fanout is performed. **SX Bet** fixtures similarly bundle game lines per `eventId`. **Predict** currently treats `event_id` as a market identifier and wraps the single market as a 1-element event response, since the upstream `event` concept on Predict is closer to a category than to a multi-market container. **Hyperliquid** maps a question id to its named outcome markets, or wraps a standalone outcome id as a single-market event.
      *
@@ -213,6 +230,7 @@ export declare class PredictorSDKClient {
      * @throws {@link PredictorSDK.PaymentRequiredError}
      * @throws {@link PredictorSDK.ForbiddenError}
      * @throws {@link PredictorSDK.NotFoundError}
+     * @throws {@link PredictorSDK.ConflictError}
      * @throws {@link PredictorSDK.TooManyRequestsError}
      * @throws {@link PredictorSDK.BadGatewayError}
      * @throws {@link PredictorSDK.ServiceUnavailableError}
@@ -221,7 +239,7 @@ export declare class PredictorSDKClient {
      *
      * @example
      *     await client.getEvent({
-     *         eventId: "KXMLBGAME-26MAY221840CLEPHI"
+     *         eventId: "KXNBAGAME-26OCT20OKCSAS"
      *     })
      */
     getEvent(request: PredictorSDK.GetEventRequest, requestOptions?: PredictorSDKClient.RequestOptions): core.HttpResponsePromise<PredictorSDK.EventResponse>;

package/dist/Client.js

@@ -75,7 +75,7 @@ export class PredictorSDKClient {
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/plans");
     }
     /**
-     * Find cross-platform market matches for sports events. Coverage is NBA, WNBA, NHL, and MLB; `canonical_events[].league` names the league and is the first segment of the canonical `event_id`. When called without parameters, returns all currently matched sports markets with cursor-based pagination (default `limit=25`, max `100`). Provide a canonical event key, Kalshi event ticker, Polymarket slug, Predict market ID, or SX Bet market ID to look up a specific event — lookups return the full match immediately and skip pagination. Every platform row includes its provider-native `event_id` for use with `GET /v1/events/{event_id}`; pass that row's `platform` value as the events endpoint's `platform` query parameter, which is required to disambiguate Predict and AlphaArcade identifiers.
+     * Find cross-platform market matches for sports events. Coverage is NBA, WNBA, NHL, MLB, and NFL; `canonical_events[].league` names the league and is the first segment of the canonical `event_id`. When called without parameters, returns all currently matched sports markets with cursor-based pagination (default `limit=25`, max `100`) — games whose date has passed are excluded unless you ask for them with `include_settled=true`. Provide a canonical event key, Kalshi event ticker, Polymarket slug, Predict market ID, or SX Bet market ID to look up a specific event — lookups return the full match immediately and skip pagination. Every platform row includes its provider-native `event_id` for use with `GET /v1/events/{event_id}`; pass that row's `platform` value as the events endpoint's `platform` query parameter, which is required to disambiguate Predict and AlphaArcade identifiers.
      *
      * @param {PredictorSDK.GetSportsMatchingMarketsRequest} request
      * @param {PredictorSDKClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -211,6 +211,10 @@ export class PredictorSDKClient {
     /**
      * Returns a paginated list of unified markets from all supported prediction market providers. Uses cursor-based pagination with default `limit=25`, max `100`.
      *
+     * Providers are walked in a fixed sequence, so without a filter the first pages are all Kalshi. Narrow the traversal with `provider` and/or `category`; both are membership filters on the same immutable catalog snapshot, both compose, and `pagination.total` always counts the filtered set rather than the whole catalog.
+     *
+     * This endpoint reads a stored snapshot rather than calling the venues, so the rows are as old as the last ingestion crawl, not as old as the request. `snapshot.observed_at` reports that age and is stable across a cursor traversal.
+     *
      * @param {PredictorSDK.GetMarketsRequest} request
      * @param {PredictorSDKClient.RequestOptions} requestOptions - Request-specific configuration.
      *
@@ -231,7 +235,7 @@ export class PredictorSDKClient {
         return core.HttpResponsePromise.fromPromise(this.__getMarkets(request, requestOptions));
     }
     async __getMarkets(request = {}, requestOptions) {
-        const { limit, cursor, category } = request;
+        const { limit, cursor, category, provider } = request;
         const _queryParams = {
             limit,
             cursor,
@@ -241,6 +245,12 @@ export class PredictorSDKClient {
                     omitUndefined: true,
                 })
                 : undefined,
+            provider: provider != null
+                ? serializers.GetMarketsRequestProvider.jsonOrThrow(provider, {
+                    unrecognizedObjectKeys: "strip",
+                    omitUndefined: true,
+                })
+                : undefined,
         };
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
@@ -450,11 +460,19 @@ export class PredictorSDKClient {
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/categories");
     }
     /**
-     * Returns a single market across the six supported platforms (Kalshi, Polymarket, Predict, SX Bet, Hyperliquid, AlphaArcade). The `market_id` is either the composite form returned by `GET /v1/markets` (`{provider}:{native_id}`, e.g. `kalshi:KXNBA-26-SAS`) or the platform-native identifier. Composite IDs dispatch unambiguously by prefix. Native IDs are routed by format inference: Kalshi tickers match the all-caps-with-hyphens shape (`KX…-…`); SX Bet hashes match `0x` + 64 hex characters; numeric ids and kebab-case slugs are shared shape between Polymarket and Predict and probe Polymarket first, falling back to Predict on 404. Hyperliquid integer outcome ids collide with Polymarket/Predict numeric ids and are deliberately not inferred — route them via the composite form (`hyperliquid:<id>`) or `?platform=hyperliquid` (alias `hl`). AlphaArcade market ids are ULIDs (26-char Crockford base32, e.g. `01KQV5TQ9CE20WPEVJZX2ETNQD`); like Hyperliquid they are not inferred in v1 — route them via the composite form (`alpha-arcade:<ulid>`) or `?platform=alpha-arcade` (alias `aa`). Pass `?platform=` explicitly to skip the probe.
+     * Returns a single market across the six supported platforms (Kalshi, Polymarket, Predict, SX Bet, Hyperliquid, AlphaArcade). The `market_id` is either the composite form returned by `GET /v1/markets` (`{provider}:{native_id}`, e.g. `kalshi:KXNBA-27-SAS`) or the platform-native identifier. Composite IDs dispatch unambiguously by prefix. Native IDs are routed by format inference: Kalshi tickers match the all-caps-with-hyphens shape (`KX…-…`); SX Bet hashes match `0x` + 64 hex characters.
+     *
+     * **A bare numeric id or kebab-case slug does not name its platform.** Polymarket and Predict share both shapes, so when `?platform=` is omitted the service probes every candidate and answers only if exactly one of them holds that identifier. If two do, the identifier names two different real markets and the request fails with `409` listing both — it does not pick one. Retry with `?platform=` or the composite form. Hyperliquid integer outcome ids collide with Polymarket/Predict numeric ids and are deliberately not inferred — route them via the composite form (`hyperliquid:<id>`) or `?platform=hyperliquid` (alias `hl`). AlphaArcade market ids are ULIDs (26-char Crockford base32, e.g. `01K0HQE3CEM2T2RDRWSCJ3V647`); like Hyperliquid they are not inferred in v1 — route them via the composite form (`alpha-arcade:<ulid>`) or `?platform=alpha-arcade` (alias `aa`).
+     *
+     * **If you already know the platform, always say so.** Every listing that hands you an identifier also hands you its platform, so the composite form — which `GET /v1/markets` returns natively in `data[].id` — or `?platform={row.platform}` costs nothing, skips the probe, and cannot 409. It is also strictly more available: the probe has to reach both candidates to prove there is no collision, so it fails when either is having an outage, while a named platform only depends on that one.
      *
      * Identity fields (id/provider/provider_id/title/status/ outcomes[].name) are strict-universal: every platform's single-market endpoint exposes them natively without a second fetch. close timestamps and parent event ids remain omitted (not nullable) — Predict's close time lives on the parent category and Polymarket's market record carries no event id.
      *
-     * The pricing tier adds per-outcome quotes (`price`/`bid`/`ask`/ `last` as 0–1 probability numbers — price IS the implied probability), a `pricing` envelope (`availability`/`scale`/ `source`/`as_of`/`neg_risk`), and market-level aggregates (`liquidity_usd`, `volume_24h_usd`, `volume_total_usd`, plus Kalshi contract-count mirrors and `open_interest`). Kalshi/ Polymarket/Predict quotes come from the same record the identity fetch returns (`pricing.source=market_record`). SX Bet, Hyperliquid, and AlphaArcade carry no pricing on the market record, so the server makes one bounded second fetch to the order book (`pricing.source=orderbook`) — SX Bet's best-odds endpoint, Hyperliquid's merged `l2Book`, or AlphaArcade's `get-full-orderbook` (a 4-sided YES/NO book; the second side's quotes are derived from the first by the cross-side complement, and the catalog midpoint serves as the price mark when the book is empty). On a book error the lookup still succeeds with identity intact and `pricing.availability` reflecting the marks. On timeout/error it degrades to `pricing.availability=unavailable` with identity intact — pricing failures never fail the lookup. Aggregates a platform doesn't natively expose are explicit `null` (e.g. Kalshi reports volume in contracts, so `volume_*_usd` stays null rather than fabricating a USD figure; its upstream `liquidity_dollars` field is deprecated and always zero, so `liquidity_usd` is null too).
+     * **What the pricing tier is for, and what it is not.** It reports the top of each venue's book, once, at the moment of your request. That is enough to see where a market is quoted, to compare venues, and to decide where to go and look harder. It is NOT an execution feed: there is no depth beyond the best level, no streaming, no per-outcome book on the platforms that publish only a market-wide mark, and nothing here is reserved for you — by the time you act, the level may be gone. Two limits are worth knowing before you write a strategy against it. First, `price` is a derived display number and a non-null `price` does not imply a tradeable one; read `pricing.availability` and prefer `bid`/`ask` for anything you intend to act on. Second, quote freshness is a property of the venue, not of this API — see *Bounding quote freshness* below. Route the actual order through the venue's own book.
+     *
+     * The pricing tier adds per-outcome quotes (`price`/`bid`/`ask`/ `last` as 0–1 probability numbers — price IS the implied probability), a `pricing` envelope (`availability`/`scale`/ `source`/`as_of`/`as_of_kind`/`observed_at`/`neg_risk`), and market-level aggregates (`liquidity_usd`, `volume_24h_usd`, `volume_total_usd`, plus Kalshi contract-count mirrors and `open_interest`). Kalshi/ Polymarket/Predict quotes come from the same record the identity fetch returns (`pricing.source=market_record`). SX Bet, Hyperliquid, and AlphaArcade carry no pricing on the market record, so the server makes one bounded second fetch to the order book (`pricing.source=orderbook`) — SX Bet's best-odds endpoint, Hyperliquid's merged `l2Book`, or AlphaArcade's `get-full-orderbook` (a 4-sided YES/NO book; the second side's quotes are derived from the first by the cross-side complement, and the catalog midpoint serves as the price mark when the book is empty — reported as `pricing.availability=indicative`, since a mark that outlives its book is not a quote). On a book error the lookup still succeeds with identity intact and `pricing.availability` reflecting the marks. On timeout/error it degrades to `pricing.availability=unavailable` with identity intact — pricing failures never fail the lookup. Predict publishes a per-market `spreadThreshold` — the widest bid/ask spread it counts as liquidity — and this route honours it, so a Predict book outside its own market's threshold reports `indicative` rather than lending its midpoint the authority of `live`. Aggregates a platform doesn't natively expose are explicit `null` (e.g. Kalshi reports volume in contracts, so `volume_*_usd` stays null rather than fabricating a USD figure; its upstream `liquidity_dollars` field is deprecated and always zero, so `liquidity_usd` is null too).
+     *
+     * **Bounding quote freshness.** `pricing.as_of` is the provider's own timestamp and does not mean the same thing on every platform — on Hyperliquid it moves with the order book, while on Kalshi it is a record write measured anywhere from 15 hours to 137 days old on markets reporting `status: open` with a live two-sided book. `pricing.as_of_kind` names which one you received (`quote` / `record_refresh` / `record_static` / `unknown`), so read it before applying an age bound to `as_of`; only `quote` tracks the quote closely enough to bound at all. `pricing.observed_at` is when this server read the quotes, means the same thing on every provider, and is therefore the field to bound when you need one threshold that behaves identically across platforms. It bounds the age of the read, not of the quote: this route reads the venue live per request and caches nothing, so on a `record_static` provider a fresh `observed_at` beside a day-old `as_of` is the honest description of what the venue served, and the executable price should come from that venue's own book.
      *
      * The `trading_fees` tier reports what the VENUE charges to trade this market — its own published fee parameters, normalized to one shape across all six platforms, so cross-venue cost comparison stops requiring six private formulas. Nothing here relates to PredictorSDK's subscription pricing. It is always present, and `trading_fees.availability` distinguishes published parameters from per-account rates that need your own venue credentials (SX Bet, Hyperliquid), from a venue that publishes nothing, and from a fee of genuinely zero. Only Kalshi costs extra upstream hops for it (its parameters live on the parent series plus any scheduled per-event override, all TTL-cached and bounded); those degrade to `availability: "unavailable"` rather than failing the lookup, exactly like the pricing tier. See the `MarketDetailTradingFees` schema for the formulas and for what is deliberately out of scope.
      *
@@ -466,6 +484,7 @@ export class PredictorSDKClient {
      * @throws {@link PredictorSDK.PaymentRequiredError}
      * @throws {@link PredictorSDK.ForbiddenError}
      * @throws {@link PredictorSDK.NotFoundError}
+     * @throws {@link PredictorSDK.ConflictError}
      * @throws {@link PredictorSDK.TooManyRequestsError}
      * @throws {@link PredictorSDK.BadGatewayError}
      * @throws {@link PredictorSDK.ServiceUnavailableError}
@@ -474,7 +493,7 @@ export class PredictorSDKClient {
      *
      * @example
      *     await client.getMarket({
-     *         marketId: "kalshi:KXNBA-26-SAS"
+     *         marketId: "kalshi:KXNBA-27-SAS"
      *     })
      */
     getMarket(request, requestOptions) {
@@ -563,6 +582,14 @@ export class PredictorSDKClient {
                         skipValidation: true,
                         breadcrumbsPrefix: ["response"],
                     }), _response.rawResponse);
+                case 409:
+                    throw new PredictorSDK.ConflictError(serializers.AmbiguousIdentifierError.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 429:
                     throw new PredictorSDK.TooManyRequestsError(serializers.ErrorResponse.parseOrThrow(_response.error.body, {
                         unrecognizedObjectKeys: "passthrough",
@@ -1018,11 +1045,15 @@ export class PredictorSDKClient {
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/polymarket/wallet/positions");
     }
     /**
-     * Returns a single event and the markets nested under it on the identified platform. The `event_id` is the platform's native identifier — a Kalshi `event_ticker`, a Polymarket event slug, an SX Bet `eventId`, a Predict market identifier, a Hyperliquid question/outcome integer id, or an AlphaArcade market ULID. The `platform` is inferred from the ID format when unambiguous (`KX…` → Kalshi, `L\d+` → SX Bet). Numeric IDs and kebab-case slugs are shared shape between Polymarket and Predict; if `?platform=` is omitted in that case, the service probes Polymarket first and falls back to Predict when Polymarket returns 404. Hyperliquid integer ids also collide with those numeric ids and require `?platform=hyperliquid` (alias `hl`). AlphaArcade ULIDs are not inferred in v1 either — require `?platform=alpha-arcade` (alias `aa`). An AlphaArcade multi-choice market resolves to an event whose nested markets are its options; a binary market (or a single option id) resolves to a single-market event. Pass `?platform=` explicitly to skip the probe.
+     * Returns a single event and the markets nested under it on the identified platform. The `event_id` is the platform's native identifier — a Kalshi `event_ticker`, a Polymarket event slug, an SX Bet `eventId`, a Predict market identifier, a Hyperliquid question/outcome integer id, or an AlphaArcade market ULID. The `platform` is inferred from the ID format when unambiguous (`KX…` → Kalshi, `L\d+` → SX Bet). The composite form returned by `GET /v1/markets` (`{provider}:{native_id}`, e.g. `predict:1607914`) also dispatches unambiguously by prefix.
+     *
+     * **A bare numeric id or kebab-case slug does not name its platform.** Polymarket and Predict share both shapes, so when `?platform=` is omitted the service probes every candidate and answers only if exactly one of them holds that identifier. If two do, the identifier names two different real events and the request fails with `409` listing both — it does not pick one. Retry with `?platform=` or the composite form. Hyperliquid integer ids also collide with those numerics and require `?platform=hyperliquid` (alias `hl`). AlphaArcade ULIDs are not inferred in v1 either — require `?platform=alpha-arcade` (alias `aa`). An AlphaArcade multi-choice market resolves to an event whose nested markets are its options; a binary market (or a single option id) resolves to a single-market event.
+     *
+     * **If you already know the platform, always say so.** Every listing that hands you an identifier also hands you its platform, so `?platform={row.platform}` (or the composite form) costs nothing, skips the probe, and cannot 409. It is also strictly more available: the probe has to reach both candidates to prove there is no collision, so it fails when either is having an outage, while a named platform only depends on that one.
      *
      * Response is minimal in v0: each market is returned with its platform-native `market_id` and a human-readable `title`. Pricing, volume, status, and timestamps are intentionally deferred — they'll be added as additive fields to `EventMarket` in a later release. The endpoint mirrors the `/v1/markets` rollout pattern (titles first, fields later).
      *
-     * **Kalshi sibling fanout.** A single Kalshi sports game lives across multiple event tickers that share a game suffix — e.g. `KXMLBGAME-26MAY221840CLEPHI` holds the moneyline, `KXMLBF5TOTAL-26MAY221840CLEPHI` holds the totals, and so on. When the supplied event_ticker belongs to a sport in the sibling registry (MLB, NBA, NFL, NHL, WNBA today), this endpoint fans out across known sibling series in parallel and merges their markets into one response. Siblings that don't exist for a particular game silently drop. Siblings that error are reported under `fanout.siblings_missing`; the primary event still returns 200 in that case. Only the primary fetch failing produces a 4xx/5xx — partial fanouts never fail the request.
+     * **Kalshi sibling fanout.** A single Kalshi sports game lives across multiple event tickers that share a game suffix — e.g. `KXMLBGAME-26AUG272145AZSF` holds the moneyline, `KXMLBF5TOTAL-26AUG272145AZSF` holds the first-five-innings totals, and so on. When the supplied event_ticker belongs to a sport in the sibling registry (MLB, NBA, NFL, NHL, WNBA today), this endpoint fans out across known sibling series in parallel and merges their markets into one response. Siblings that don't exist for a particular game silently drop. Siblings that error are reported under `fanout.siblings_missing`; the primary event still returns 200 in that case. Only the primary fetch failing produces a 4xx/5xx — partial fanouts never fail the request.
      *
      * **Polymarket** events already nest the moneyline plus all spread/totals/game-level prop markets under a single event slug, so no fanout is performed. **SX Bet** fixtures similarly bundle game lines per `eventId`. **Predict** currently treats `event_id` as a market identifier and wraps the single market as a 1-element event response, since the upstream `event` concept on Predict is closer to a category than to a multi-market container. **Hyperliquid** maps a question id to its named outcome markets, or wraps a standalone outcome id as a single-market event.
      *
@@ -1034,6 +1065,7 @@ export class PredictorSDKClient {
      * @throws {@link PredictorSDK.PaymentRequiredError}
      * @throws {@link PredictorSDK.ForbiddenError}
      * @throws {@link PredictorSDK.NotFoundError}
+     * @throws {@link PredictorSDK.ConflictError}
      * @throws {@link PredictorSDK.TooManyRequestsError}
      * @throws {@link PredictorSDK.BadGatewayError}
      * @throws {@link PredictorSDK.ServiceUnavailableError}
@@ -1042,7 +1074,7 @@ export class PredictorSDKClient {
      *
      * @example
      *     await client.getEvent({
-     *         eventId: "KXMLBGAME-26MAY221840CLEPHI"
+     *         eventId: "KXNBAGAME-26OCT20OKCSAS"
      *     })
      */
     getEvent(request, requestOptions) {
@@ -1131,6 +1163,14 @@ export class PredictorSDKClient {
                         skipValidation: true,
                         breadcrumbsPrefix: ["response"],
                     }), _response.rawResponse);
+                case 409:
+                    throw new PredictorSDK.ConflictError(serializers.AmbiguousIdentifierError.parseOrThrow(_response.error.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }), _response.rawResponse);
                 case 429:
                     throw new PredictorSDK.TooManyRequestsError(serializers.ErrorResponse.parseOrThrow(_response.error.body, {
                         unrecognizedObjectKeys: "passthrough",

package/dist/api/client/requests/GetEventRequest.d.ts

@@ -2,12 +2,18 @@ import type * as PredictorSDK from "../../index.js";
 /**
  * @example
  *     {
- *         eventId: "KXMLBGAME-26MAY221840CLEPHI"
+ *         eventId: "KXNBAGAME-26OCT20OKCSAS"
  *     }
  */
 export interface GetEventRequest {
-    /** Platform-native event identifier. Examples per platform: Kalshi event ticker (`KXMLBGAME-26MAY221840CLEPHI`), Polymarket event slug (`mlb-cle-phi-2026-05-22`), SX Bet event id (`L10073358`), Predict market id (`110629`), Hyperliquid question or outcome integer id (`19` or `172`; requires `?platform=hyperliquid` since integer ids aren't inferred). */
+    /**
+     * Platform-native event identifier. Examples per platform: Kalshi event ticker (`KXNBAGAME-26OCT20OKCSAS`), Polymarket event slug (`mlb-tor-cle-2026-09-02`), SX Bet event id (`L19766755`), Predict market id (`1607914`), Hyperliquid question or outcome integer id (requires `?platform=hyperliquid` since integer ids aren't inferred). The composite `{provider}:{native_id}` form (e.g. `predict:1607914`) is accepted here too and dispatches without probing.
+     *
+     * **A bare numeric id or slug is not unique across platforms.** Polymarket and Predict both use these shapes and their id spaces overlap, so sending one without a platform can fail with `409` (see that response). Pass `?platform=` — every row of `GET /v1/matching-markets/sports` carries the `platform` that goes with its `event_id`.
+     *
+     * **Sports identifiers expire.** Game tickers and slugs are delisted once an event settles, and Hyperliquid ids roll over daily. Take current ones from `GET /v1/matching-markets/sports` (every platform row carries its provider-native `event_id`) rather than copying one out of this reference.
+     */
     eventId: string;
-    /** Optional platform override. When omitted, inferred from the `event_id` format: `KX…` → Kalshi, `L\d+` → SX Bet. Numeric IDs and kebab-case slugs are shared shape between Polymarket and Predict; in that case the service probes Polymarket first and falls back to Predict on 404. Hyperliquid question/outcome integer ids collide with these numerics and are not inferred — pass `?platform=hyperliquid` (alias `hl`). Pass `platform` explicitly to skip the probe. */
+    /** Optional platform override. When omitted, inferred from the `event_id` format: `KX…` → Kalshi, `L\d+` → SX Bet. Numeric IDs and kebab-case slugs are shared shape between Polymarket and Predict; in that case the service probes both and returns `409` rather than guessing if the identifier resolves on both. Hyperliquid question/outcome integer ids collide with these numerics and are not inferred — pass `?platform=hyperliquid` (alias `hl`). Passing `platform` explicitly skips the probe entirely and is the recommended call whenever you know it. Supplying a value that contradicts a composite `{provider}:` prefix is a `400`. */
     platform?: PredictorSDK.GetEventRequestPlatform;
 }

package/dist/api/client/requests/GetMarketRequest.d.ts

@@ -2,12 +2,18 @@ import type * as PredictorSDK from "../../index.js";
 /**
  * @example
  *     {
- *         marketId: "kalshi:KXNBA-26-SAS"
+ *         marketId: "kalshi:KXNBA-27-SAS"
  *     }
  */
 export interface GetMarketRequest {
-    /** Composite (`{provider}:{native_id}`) or platform-native market identifier. Examples per platform: Kalshi market ticker (`KXNBA-26-SAS`), Polymarket numeric id or slug (`540817` or `new-rhianna-album-before-gta-vi-926`), Predict market id (`356635`), SX Bet `marketHash` (`0x…64hex`), Hyperliquid outcome id (use the composite `hyperliquid:172` or `?platform=hyperliquid` — bare integer ids aren't inferred). */
+    /**
+     * Composite (`{provider}:{native_id}`) or platform-native market identifier. Examples per platform: Kalshi market ticker (`KXNBA-27-SAS`), Polymarket numeric id or slug (`540817` or `mlb-tor-cle-2026-09-02`), Predict market id (`356635`), SX Bet `marketHash` (`0x…64hex`), Hyperliquid outcome id (use the composite `hyperliquid:<outcome-id>` or `?platform=hyperliquid` — bare integer ids aren't inferred).
+     *
+     * **A bare numeric id or slug is not unique across platforms.** Polymarket and Predict both use these shapes and their id spaces overlap, so sending one without a platform can fail with `409` (see that response). Prefer the composite form — it is what `GET /v1/markets` returns in `data[].id` — or pass `?platform=`.
+     *
+     * **Sports identifiers expire.** Kalshi game tickers, Polymarket game slugs, and Hyperliquid outcome ids are recycled or delisted as events settle — Hyperliquid's live catalog is a handful of daily-recurring outcomes, so any specific integer id there is valid for roughly a day. Take current ids from `GET /v1/markets` or `GET /v1/matching-markets/sports` rather than copying one out of this reference. Long-dated markets (Kalshi season futures, multi-year AlphaArcade questions) and settled Polymarket/Predict/SX Bet ids stay resolvable.
+     */
     marketId: string;
-    /** Optional platform override. When omitted, inferred from the composite prefix or from the native ID format (`KX…` → Kalshi, `0x…64hex` → SX Bet). Numeric IDs and kebab-case slugs are shared shape between Polymarket and Predict; in that case the service probes Polymarket first and falls back to Predict on 404. Hyperliquid integer ids collide with these numerics and are not inferred — use the composite `hyperliquid:<id>` or `?platform=hyperliquid` (alias `hl`). Pass `platform` explicitly to skip the probe. When the override contradicts a composite prefix (e.g. `kalshi:X` with `?platform=polymarket`), the request returns 400. */
+    /** Optional platform override. When omitted, inferred from the composite prefix or from the native ID format (`KX…` → Kalshi, `0x…64hex` → SX Bet). Numeric IDs and kebab-case slugs are shared shape between Polymarket and Predict; in that case the service probes both and returns `409` rather than guessing if the identifier resolves on both. Hyperliquid integer ids collide with these numerics and are not inferred — use the composite `hyperliquid:<id>` or `?platform=hyperliquid` (alias `hl`). Passing `platform` explicitly skips the probe entirely and is the recommended call whenever you know it. When the override contradicts a composite prefix (e.g. `kalshi:X` with `?platform=polymarket`), the request returns 400. */
     platform?: PredictorSDK.GetMarketRequestPlatform;
 }

package/dist/api/client/requests/GetMarketsRequest.d.ts

@@ -10,4 +10,14 @@ export interface GetMarketsRequest {
     cursor?: string;
     /** Canonical top-level category filter. This is PredictorSDK's normalized category, not a provider-native tag. Cursors are bound to the category filter used to create them. */
     category?: PredictorSDK.MarketCategory;
+    /**
+     * Restrict the page to one provider, matched against each row's own `provider` value. Without it, providers are walked in the order below and a caller wanting a later one has to paginate through every earlier provider's rows first.
+     *
+     * Only the canonical provider IDs are accepted, case-insensitively. Any other value returns `400` listing the legal ones — an unrecognized filter is never ignored, because a silently dropped filter returns a full unfiltered page that looks filtered.
+     *
+     * `pagination.total` counts only the selected provider's rows, and cursors are bound to the filter that created them: replay a `next_cursor` with the same `provider` value, or start again from the first page.
+     *
+     * This is a catalog membership filter, and it is spelled `provider` because that is the field it selects on. It is unrelated to the `platform` override on `GET /v1/markets/{market_id}` and `GET /v1/events/{event_id}`, which names the venue an identifier should be resolved against rather than filtering a list.
+     */
+    provider?: PredictorSDK.GetMarketsRequestProvider;
 }

package/dist/api/client/requests/GetSportsMatchingMarketsRequest.d.ts

@@ -7,18 +7,24 @@ export interface GetSportsMatchingMarketsRequest {
     limit?: number;
     /** Opaque cursor from a previous response's `pagination.nextCursor` in the SDKs (raw JSON: `pagination.next_cursor`). Must be used with the same filter set — a cursor from `include_settled=true` cannot be replayed against `include_settled=false` and will return `400`. */
     cursor?: string;
-    /** When `true`, include settled/archived events alongside currently live matches. Defaults to `false`. */
+    /**
+     * Selects which events this request draws from, in list mode and in lookup mode alike. Defaults to `false`: only events whose scheduled start has not certainly passed — today's games, plus a one-day grace so a late start that runs past midnight Eastern is never dropped mid-play. Set it to `true` to also get events whose game date is further in the past, including ones a venue still lists as open.
+     *
+     * A venue can keep quoting a market for months after the game (a 94-day-old row was still `status: open` with a live two-sided book when this was written), so the endpoint filters on the game date it already holds — the trailing date of the canonical `event_id` — rather than on an upstream status it cannot verify. Nothing is reported as settled that the venue has not settled; these events are simply not *current*, which is what the default page is for.
+     *
+     * Because it selects the population, a lookup (`?event_id=`, `?polymarket_market_slug=`, …) for a past-dated event answers `200` with an empty `markets` object unless this is `true`.
+     */
     includeSettled?: boolean;
     /** When `true`, add `canonical_events` with normalized event, submarket, line, segment, outcome, and exact source market/outcome identity. This is an identity mapping only; fetch current status, quotes, and liquidity from the referenced market resources. Defaults to `false` so the compact Dome-compatible response is unchanged. */
     includeSubmarkets?: boolean;
-    /** Canonical event key(s) to look up directly (for example, `mlb-tex-hou-2026-07-31`). Provide the parameter multiple times for multiple events, up to 100 unique keys. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
+    /** Canonical event key(s) to look up directly (for example, `nba-okc-sas-2026-10-20`). Provide the parameter multiple times for multiple events, up to 100 unique keys. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
     eventId?: string | string[];
-    /** Kalshi event ticker(s) to find matching markets for (e.g. `KXNFLGAME-25AUG16ARIDEN`). Provide the parameter multiple times for multiple tickers, up to 100 unique values. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
+    /** Kalshi event ticker(s) to find matching markets for (e.g. `KXNBAGAME-26OCT20OKCSAS`). Provide the parameter multiple times for multiple tickers, up to 100 unique values. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
     kalshiEventTicker?: string | string[];
-    /** Polymarket market slug(s) to find matching markets for (e.g. `nfl-ari-den-2025-08-16`). Provide the parameter multiple times for multiple slugs, up to 100 unique values. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
+    /** Polymarket market slug(s) to find matching markets for (e.g. `mlb-tor-cle-2026-09-02`). Provide the parameter multiple times for multiple slugs, up to 100 unique values. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
     polymarketMarketSlug?: string | string[];
-    /** Predict market ID(s) to find matching markets for (e.g. `110629`). Provide the parameter multiple times for multiple IDs, up to 100 unique values. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
+    /** Predict market ID(s) to find matching markets for (e.g. `1607914`). Provide the parameter multiple times for multiple IDs, up to 100 unique values. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
     predictMarketId?: string | string[];
-    /** SX Bet market ID(s) to find matching markets for (e.g. `0x4c000abdbf197ef32ecdf15561b1d636f1e5b02629f466678757fd83e2ec3599`). Provide the parameter multiple times for multiple IDs, up to 100 unique values. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
+    /** SX Bet market ID(s) to find matching markets for (e.g. `0xb4d047a709aae881e5ccad9d123592967644ee1df1f17078c762b388e41b81c5`). Provide the parameter multiple times for multiple IDs, up to 100 unique values. Only one filter type may be used per request. Lookup mode — pagination parameters are ignored. */
     sxbetMarketId?: string | string[];
 }

package/dist/api/errors/ConflictError.d.ts

@@ -0,0 +1,7 @@
+import type * as core from "../../core/index.js";
+import * as errors from "../../errors/index.js";
+import type * as PredictorSDK from "../index.js";
+export declare class ConflictError extends errors.PredictorSDKError {
+    readonly body: PredictorSDK.AmbiguousIdentifierError;
+    constructor(body: PredictorSDK.AmbiguousIdentifierError, rawResponse?: core.RawResponse);
+}

package/dist/api/errors/ConflictError.js

@@ -0,0 +1,17 @@
+// This file was auto-generated by Fern from our API Definition.
+import * as errors from "../../errors/index.js";
+export class ConflictError extends errors.PredictorSDKError {
+    constructor(body, rawResponse) {
+        super({
+            message: "ConflictError",
+            statusCode: 409,
+            body: body,
+            rawResponse: rawResponse,
+        });
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = "ConflictError";
+    }
+}

package/dist/api/errors/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./BadGatewayError.js";
 export * from "./BadRequestError.js";
+export * from "./ConflictError.js";
 export * from "./ForbiddenError.js";
 export * from "./NotFoundError.js";
 export * from "./PaymentRequiredError.js";

package/dist/api/errors/index.js

@@ -1,5 +1,6 @@
 export * from "./BadGatewayError.js";
 export * from "./BadRequestError.js";
+export * from "./ConflictError.js";
 export * from "./ForbiddenError.js";
 export * from "./NotFoundError.js";
 export * from "./PaymentRequiredError.js";

package/dist/api/types/AmbiguousIdentifierError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error body returned with HTTP 409. The identifier you sent is well-formed but not unique: it names a real resource on more than one platform, and nothing in the request says which one you meant. Polymarket and Predict share both the bare-numeric and kebab-case identifier shapes and their id spaces genuinely overlap, so this is a routine outcome rather than an edge case — measured 2026-08-25, 53 of 93 Predict market ids drawn from `GET /v1/matching-markets/sports` also resolved on Polymarket.
+ *
+ * `candidates` lists exactly the platforms the identifier resolved on, in a stable order, and every entry is a legal `?platform=` value. Retry the same identifier with `?platform={candidate}`, or with the composite `{platform}:{id}` form, and the lookup is deterministic. Clients that fan out over identifiers should handle 409 by re-issuing with the platform they already know from the listing that produced the id — every list and matching response that emits an identifier also emits its platform.
+ */
+export interface AmbiguousIdentifierError {
+    /** Short machine-stable reason, e.g. `ambiguous market_id`. */
+    error: string;
+    /** Human-readable detail naming the identifier, the platforms it resolved on, and how to disambiguate. */
+    message?: string;
+    /** The platforms this identifier resolved on. Each value is accepted verbatim by the `platform` query parameter. */
+    candidates: string[];
+    statusCode: number;
+}

package/dist/api/types/AmbiguousIdentifierError.js

@@ -0,0 +1,2 @@
+// This file was auto-generated by Fern from our API Definition.
+export {};

package/dist/api/types/CanonicalSportsEvent.d.ts

@@ -2,9 +2,9 @@ import type * as PredictorSDK from "../index.js";
 export interface CanonicalSportsEvent {
     /** Stable canonical event key. */
     eventId: string;
-    /** Canonical sport slug. `basketball`, `hockey`, or `baseball` today. */
+    /** Canonical sport slug. `basketball`, `hockey`, `baseball`, or `football` today. */
     sport?: string;
-    /** Canonical league slug. Cross-platform matching covers `nba`, `wnba`, `nhl`, and `mlb` today. The value is the first segment of `event_id`, so `wnba-tor-wsh-2026-08-19` is a WNBA game. Treat this as an open set — leagues are added without a breaking change. */
+    /** Canonical league slug. Cross-platform matching covers `nba`, `wnba`, `nhl`, `mlb`, and `nfl` today. The value is the first segment of `event_id`, so `nba-okc-sas-2026-10-20` is an NBA game. Treat this as an open set — leagues are added without a breaking change. */
     league?: string;
     title: string;
     participants?: PredictorSDK.CanonicalSportsParticipant[];

package/dist/api/types/CanonicalSportsSourceMarket.d.ts

@@ -1,7 +1,11 @@
 import type * as PredictorSDK from "../index.js";
 export interface CanonicalSportsSourceMarket {
     provider: PredictorSDK.CanonicalSportsSourceMarketProvider;
-    /** Exact provider-native market identifier. */
+    /**
+     * Exact provider-native market identifier. It resolves on `GET /v1/markets/{market_id}`, either as-is or prefixed with this row's `provider` in the composite form `{provider}:{market_id}`.
+     *
+     * One provider can contribute MORE THAN ONE entry to the same submarket, because a provider is free to model one canonical market as several native ones. Kalshi does exactly that for a game moneyline: it lists one binary market per team ("Arizona wins", "San Francisco wins"), so a Kalshi moneyline row appears twice, once per team ticker, each with its own `yes`/`no` outcomes. Group by `provider` if you need one row per venue; do not assume the list has at most one entry per provider.
+     */
     marketId: string;
     marketName?: string;
     marketSlug?: string;

package/dist/api/types/CanonicalSportsSourceOutcome.d.ts

@@ -2,7 +2,13 @@ export interface CanonicalSportsSourceOutcome {
     /** Canonical outcome this source-native selection represents. */
     canonicalOutcomeKey: string;
     label?: string;
-    /** Exact provider-native outcome/token identifier when available. SX Bet exposes one market hash and two named positions rather than separate outcome tokens, so its source-local selection reference is `<market_hash>:1` or `<market_hash>:2`. This field is never a universal cross-provider outcome ID. */
+    /**
+     * Exact provider-native outcome identifier. It is never a universal cross-provider outcome ID.
+     *
+     * On every provider this is the same value `GET /v1/markets/{market_id}` returns as `outcomes[].outcome_id` for the market named by this row's `market_id`, so the two surfaces join directly.
+     *
+     * `polymarket`, `predict` and `alpha-arcade` publish a globally unique per-outcome token (Polymarket CLOB token id, Predict on-chain id, AlphaArcade CLOB token id). `sxbet` and `kalshi` publish no per-outcome token at all, so their references are market-scoped and must be read together with `market_id`: an SX Bet market has one hash and two named positions (`outcomeOne` / `outcomeTwo`), and a Kalshi market is binary (`yes` / `no`). Both are the spelling the venue itself uses to address a side — SX Bet keys its order-book snapshot by `outcomeOne`/`outcomeTwo`, and Kalshi keys its book by `yes`/`no` and reports a trade's `taker_side` the same way.
+     */
     outcomeId?: string;
     /** Optional source-native side such as `yes` or `no`. */
     side?: string;

package/dist/api/types/EventMarket.d.ts

@@ -1,5 +1,5 @@
 export interface EventMarket {
-    /** Platform-native market identifier. Kalshi ticker (`KXMLBGAME-26MAY221840CLEPHI-CLE`), Polymarket numeric market id, SX Bet `marketHash`, or Predict market id. */
+    /** Platform-native market identifier. Kalshi ticker (`KXMLBGAME-26AUG272145AZSF-AZ`), Polymarket numeric market id, SX Bet `marketHash`, or Predict market id. */
     marketId: string;
     /** Human-readable market title/question. */
     title: string;

package/dist/api/types/GetMarketsRequestProvider.d.ts

@@ -0,0 +1,9 @@
+export declare const GetMarketsRequestProvider: {
+    readonly Kalshi: "kalshi";
+    readonly Polymarket: "polymarket";
+    readonly Predict: "predict";
+    readonly Sxbet: "sxbet";
+    readonly Hyperliquid: "hyperliquid";
+    readonly AlphaArcade: "alpha-arcade";
+};
+export type GetMarketsRequestProvider = (typeof GetMarketsRequestProvider)[keyof typeof GetMarketsRequestProvider];

package/dist/api/types/GetMarketsRequestProvider.js

@@ -0,0 +1,9 @@
+// This file was auto-generated by Fern from our API Definition.
+export const GetMarketsRequestProvider = {
+    Kalshi: "kalshi",
+    Polymarket: "polymarket",
+    Predict: "predict",
+    Sxbet: "sxbet",
+    Hyperliquid: "hyperliquid",
+    AlphaArcade: "alpha-arcade",
+};

package/dist/api/types/MarketDetailOutcome.d.ts

@@ -3,7 +3,13 @@ export interface MarketDetailOutcome {
     name: string;
     /** Stable per-platform key for this outcome: Kalshi `yes`/`no`, Polymarket CLOB token id, Predict on-chain id, SX Bet `outcomeOne`/`outcomeTwo`, Hyperliquid coin encoding (`#<10*outcome+side>`). The join key for future per-outcome sub-resources (order-book depth). */
     outcomeId?: string;
-    /** Current implied probability of this outcome in 0–1 — the headline field, equal to the implied probability on every supported platform. Derivation cascade: mid of bid/ask when two-sided → the single available side → last trade → platform mark (Polymarket `outcomePrices`, which preserves 0/1 resolution marks on settled markets). Because the cascade differs by what each platform exposes, `price` is a DISPLAY number — when comparing across platforms or sizing trades, prefer `bid`/`ask` directly where present. Null when no quote of any kind exists. GUARANTEE: when `pricing.availability` is `live`, `price` is non-null on every outcome. Values are rounded to at most 6 decimal places. */
+    /**
+     * Current implied probability of this outcome in 0–1 — the headline field, equal to the implied probability on every supported platform. Derivation cascade: mid of bid/ask when two-sided → the single available side → last trade → platform mark (Polymarket `outcomePrices`, which preserves 0/1 resolution marks on settled markets; AlphaArcade's catalog midpoint). Because the cascade differs by what each platform exposes, `price` is a DISPLAY number — when comparing across platforms or sizing trades, prefer `bid`/`ask` directly where present. Null when no quote of any kind exists.
+     *
+     * **A non-null `price` does not mean a tradeable price.** The last two rungs of the cascade produce a number with no book behind it, and the mid of a 0.01 / 0.99 book produces a confident-looking 0.5 that no one will fill. Read `pricing.availability` first: `live` says at least one outcome has a book the venue treats as quoted; `indicative` says every price here is a mark, a lone side, or a book the venue's own spread threshold rejects.
+     *
+     * GUARANTEE: when `pricing.availability` is `live` or `indicative`, `price` is non-null on every outcome. Values are rounded to at most 6 decimal places.
+     */
     price: number | null;
     /** Best bid for this outcome in 0–1 probability. Null when that book side is empty or the platform doesn't publish per-outcome quotes on the record (Polymarket non-primary outcomes). Hyperliquid's second side is derived from the merged book complement (`1 − first-side ask`), matching the platform's order-book structure; no other platform synthesizes bid from `1 − ask`. */
     bid: number | null;

package/dist/api/types/MarketDetailPricing.d.ts

@@ -1,19 +1,62 @@
 import type * as PredictorSDK from "../index.js";
 /**
  * Market-wide quote metadata for the pricing tier. Always present on the response; `availability` tells the truth about what the tier could hydrate instead of leaving consumers to guess from nulls.
+ *
+ * **Bounding quote freshness.** `as_of` is the provider's own stamp and means something different on each platform, so read `as_of_kind` before applying an age bound to it — only `as_of_kind: quote` tracks the quote closely enough to bound at all, and how tight that bound can be still varies by venue. `observed_at` is PredictorSDK's own read time and means the same thing on every provider, so it is the field to bound when you need one threshold that behaves identically across platforms.
  */
 export interface MarketDetailPricing {
-    /** `live` — every outcome carries a price. `partial` — some but not all outcomes priced. `no_quotes` — the pricing fetch succeeded but the book is empty (SX Bet or Hyperliquid with no resting orders; Kalshi provisional/multivariate markets whose quotes are empty-book placeholders). `unavailable` — the pricing enrichment fetch failed or timed out (SX Bet/Hyperliquid); identity fields are still served. */
+    /**
+     * How completely — and how honestly — the pricing tier hydrated. It answers two questions in this precedence order: did every outcome get a price, and is any of those prices backed by a book you could actually cross.
+     *
+     * `live` — every outcome carries a price AND at least one outcome has a two-sided book the venue itself treats as quoted. **This is the only value that licenses reading `price` as a tradeable level.**
+     *
+     * `indicative` — every outcome carries a price, but no outcome has such a book behind it. The prices are marks, one side of a book with nothing facing it, or a two-sided book wider than the venue's own published spread threshold for that market. Concretely: an AlphaArcade market whose order book is empty, where the catalog midpoint is the only price left standing; a Predict market quoted 0.01 / 0.99, whose 0.5 midpoint is arithmetic rather than a market (Predict publishes a per-market `spreadThreshold` and this server honours it); a settled Polymarket market whose 1/0 `outcomePrices` are resolution marks; or a book with one resting order and nothing on the other side. `price` is still populated and still the venue's own number — treat it as roughly where the market is thought to be, never as a level you can trade or arbitrage against. **Filter or flag `indicative` before computing cross-venue edges**: an `indicative` 0.5 next to a `live` 0.735 elsewhere is not a 23¢ opportunity, it is one venue with no book.
+     *
+     * `partial` — some but not all outcomes priced. Incompleteness is reported ahead of quote quality because it is the louder warning, so a `partial` market says nothing about the book behind the prices it does carry.
+     *
+     * `no_quotes` — the pricing read succeeded and there is nothing at all: no book and no mark (SX Bet or Hyperliquid with no resting orders; Kalshi provisional/multivariate markets whose quotes are empty-book placeholders; AlphaArcade markets that have never traded). An empty book truthfully read is still an observation, so `observed_at` is populated.
+     *
+     * `unavailable` — the pricing enrichment fetch failed or timed out (SX Bet/Hyperliquid); identity fields are still served and `observed_at` is null.
+     */
     availability: PredictorSDK.MarketDetailPricingAvailability;
     /** Self-describing unit declaration for all price fields. Single canonical scale today; new values would be added alongside (never replacing) this one. */
     scale: PredictorSDK.MarketDetailPricingScale;
     /** Where the quotes came from. `market_record` — embedded in the same single-market record as the identity fetch (Kalshi, Polymarket, Predict). `orderbook` — required one bounded second fetch against the platform's order-book surface (SX Bet `/orderbook-v3/snapshot`, Hyperliquid `l2Book`). */
     source: PredictorSDK.MarketDetailPricingSource;
     /**
-     * Quote freshness as RFC3339. When the two sides carry independent upstream timestamps, this is the OLDER of them — a conservative floor that never over-claims freshness. Hyperliquid uses the `l2Book` server timestamp. Null when the upstream record carries no quote timestamp at all (Predict, AlphaArcade, and SX Bet) — treat freshness as UNKNOWN, not as fresh. Timestamps come from each platform's own clock; for Kalshi/Polymarket the value is the record's last-update time, the closest the platform exposes to a quote timestamp.
-     * SX Bet moved from timestamped to null at its V3 order-book cutover (2026-08-25): V3 publishes an opaque monotonic book `version` and no wall-clock stamp anywhere, and server ingest time is not substituted because it would masquerade as an upstream stamp.
+     * The upstream timestamp on this platform's own clock, as RFC3339. When the two sides carry independent stamps this is the OLDER of them — a conservative floor that never over-claims freshness. Null when the record carries no timestamp at all (Predict, AlphaArcade, and SX Bet).
+     *
+     * **This field is NOT a uniform freshness bound. Read `as_of_kind` first.** What it measures differs per platform: on Hyperliquid it is the order book's server time and moves with the book, while on Kalshi it is a record write that does not move while the market is quoted. Measured live on 2026-08-24 over two runs — 100 open markets read twice 7.5 minutes apart, and 96 open markets read twice 11 minutes apart:
+     *
+     * * `kalshi` — **15 hours to 137 days old** on markets reporting `status: open` and `availability: live` with a real two-sided book. The age tracks how long ago the record was last written, so it depends entirely on the market: same-day game markets ran a median of ~23 h in one sample and ~43 h in another, while a broad sample of the market list ran a median of ~101 days (`CHINAUSGDP-30`, `status: open`, quoted 0.15 / 0.19, was stamped 2026-04-09). Advanced on 0 of 39 and 0 of 42 markets across the two runs, including five whose prices moved inside the window. **Not boundable at any threshold — do not infer one from these numbers.**
+     * * `polymarket` — 45 s to 405 s old; advanced on 60 of 60 and 25 of 25 markets, while only 1 of those 25 prices changed. Values recur identically across dozens of unrelated markets (one batch write, not one quote). Bounds record age in minutes, not quote age in seconds.
+     * * `sxbet` — a real per-side quote stamp on the V2 best-odds path, but it marks when the resting top-of-book order was posted, so on a thin book it is legitimately old: measured 39 s to 2.5 h, median ~24 min. It advances when the quote advances, which is what makes it a quote stamp — but size the bound to the venue's liquidity, not in seconds. Null from the 2026-08-25 V3 cutover onward.
+     * * `hyperliquid` — the `l2Book` server timestamp, a real quote stamp and the one field here that genuinely supports a seconds-scale bound: polled directly it tracks wall clock to the second.
+     * * `predict`, `alpha-arcade` — always null.
+     *
+     * These ranges are observed behaviour, not a contract: they are published so a consumer can pick a threshold from measured data rather than guessing, and they can change whenever a venue changes how it writes its records. Server ingest time is never substituted into this field — that would masquerade as an upstream stamp. Use `observed_at` for the read time.
      */
     asOf: Date | null;
+    /**
+     * What `as_of` MEASURES on this provider, so one consumer code path can bound freshness tightly where the value is a quote time and refuse to pretend where it is not. Always present; `unknown` whenever `as_of` is null, never an empty string.
+     *
+     * `quote` — the stamp advances when the quote advances, so an age bound on it is meaningful. Hyperliquid (`l2Book` server time) and SX Bet's V2 best-odds path. How TIGHT that bound can be still depends on the venue: Hyperliquid's tracks wall clock to the second, while SX Bet's marks when the resting top-of-book order was posted and is legitimately tens of minutes old on a thin book. Size the threshold to the venue's liquidity; a blanket seconds-scale bound rejects most of SX Bet.
+     *
+     * `record_refresh` — the stamp advances on a periodic rewrite of the provider's record, independent of whether the quote moved. Bounds RECORD age (minutes), not quote age. Polymarket.
+     *
+     * `record_static` — the stamp does not advance while the market is actively quoted, so it bounds nothing at any threshold. Kalshi. Treat quote freshness as unknown here and do not gate on `as_of`; bound `observed_at` instead and take executable price from the venue's own book.
+     *
+     * `unknown` — `as_of` is null: the record carries no timestamp of any kind (Predict, AlphaArcade, SX Bet V3). Kept distinct from `record_static` because the underlying fact differs even though the consumer's action does not.
+     */
+    asOfKind: PredictorSDK.MarketDetailPricingAsOfKind;
+    /**
+     * When PREDICTORSDK read these quotes, as RFC3339 — an observation timestamp, not an upstream one. Named `observed_at` rather than `as_of` for the same reason `trading_fees.observed_at` is: `as_of` is the provider's own stamp, and reusing the name for a differently-defined value would bake that confusion into a second field.
+     *
+     * This is the one timestamp on the response whose definition does not vary by platform, which makes it the field to bound when you need a single threshold that behaves identically everywhere. It bounds the age of the READ, not the age of the quote: on a `record_static` provider a fresh `observed_at` beside a 23-hour `as_of` is the honest description of what the venue served. `/v1/markets/{market_id}` reads the venue live on every request and caches nothing, so this stamp is the request time.
+     *
+     * Taken BEFORE the upstream call, so it is never newer than the moment the quotes were actually observed and `now - observed_at` never understates their age. Null only when `availability` is `unavailable` — no quotes were observed, so there is nothing to stamp. Populated for `no_quotes`, where an empty book is a successful observation.
+     */
+    observedAt: Date | null;
     /** True when this market belongs to a negative-risk multi-outcome event (Polymarket `negRisk`, Predict `isNegRisk`). On a multi-outcome record, outcome prices intentionally need not sum to 1 — do not "normalize" the book. Note that for the BINARY member markets these platforms serve today the flag signals event-level structure (this market is one leg of a mutually-exclusive set); the binary pair itself still sums to ~1. Omitted when false. */
     negRisk?: boolean;
 }

package/dist/api/types/MarketDetailPricingAsOfKind.d.ts

@@ -0,0 +1,18 @@
+/**
+ * What `as_of` MEASURES on this provider, so one consumer code path can bound freshness tightly where the value is a quote time and refuse to pretend where it is not. Always present; `unknown` whenever `as_of` is null, never an empty string.
+ *
+ * `quote` — the stamp advances when the quote advances, so an age bound on it is meaningful. Hyperliquid (`l2Book` server time) and SX Bet's V2 best-odds path. How TIGHT that bound can be still depends on the venue: Hyperliquid's tracks wall clock to the second, while SX Bet's marks when the resting top-of-book order was posted and is legitimately tens of minutes old on a thin book. Size the threshold to the venue's liquidity; a blanket seconds-scale bound rejects most of SX Bet.
+ *
+ * `record_refresh` — the stamp advances on a periodic rewrite of the provider's record, independent of whether the quote moved. Bounds RECORD age (minutes), not quote age. Polymarket.
+ *
+ * `record_static` — the stamp does not advance while the market is actively quoted, so it bounds nothing at any threshold. Kalshi. Treat quote freshness as unknown here and do not gate on `as_of`; bound `observed_at` instead and take executable price from the venue's own book.
+ *
+ * `unknown` — `as_of` is null: the record carries no timestamp of any kind (Predict, AlphaArcade, SX Bet V3). Kept distinct from `record_static` because the underlying fact differs even though the consumer's action does not.
+ */
+export declare const MarketDetailPricingAsOfKind: {
+    readonly Quote: "quote";
+    readonly RecordRefresh: "record_refresh";
+    readonly RecordStatic: "record_static";
+    readonly Unknown: "unknown";
+};
+export type MarketDetailPricingAsOfKind = (typeof MarketDetailPricingAsOfKind)[keyof typeof MarketDetailPricingAsOfKind];

package/dist/api/types/MarketDetailPricingAsOfKind.js

@@ -0,0 +1,18 @@
+// This file was auto-generated by Fern from our API Definition.
+/**
+ * What `as_of` MEASURES on this provider, so one consumer code path can bound freshness tightly where the value is a quote time and refuse to pretend where it is not. Always present; `unknown` whenever `as_of` is null, never an empty string.
+ *
+ * `quote` — the stamp advances when the quote advances, so an age bound on it is meaningful. Hyperliquid (`l2Book` server time) and SX Bet's V2 best-odds path. How TIGHT that bound can be still depends on the venue: Hyperliquid's tracks wall clock to the second, while SX Bet's marks when the resting top-of-book order was posted and is legitimately tens of minutes old on a thin book. Size the threshold to the venue's liquidity; a blanket seconds-scale bound rejects most of SX Bet.
+ *
+ * `record_refresh` — the stamp advances on a periodic rewrite of the provider's record, independent of whether the quote moved. Bounds RECORD age (minutes), not quote age. Polymarket.
+ *
+ * `record_static` — the stamp does not advance while the market is actively quoted, so it bounds nothing at any threshold. Kalshi. Treat quote freshness as unknown here and do not gate on `as_of`; bound `observed_at` instead and take executable price from the venue's own book.
+ *
+ * `unknown` — `as_of` is null: the record carries no timestamp of any kind (Predict, AlphaArcade, SX Bet V3). Kept distinct from `record_static` because the underlying fact differs even though the consumer's action does not.
+ */
+export const MarketDetailPricingAsOfKind = {
+    Quote: "quote",
+    RecordRefresh: "record_refresh",
+    RecordStatic: "record_static",
+    Unknown: "unknown",
+};

package/dist/api/types/MarketDetailPricingAvailability.d.ts

@@ -1,6 +1,19 @@
-/** `live` — every outcome carries a price. `partial` — some but not all outcomes priced. `no_quotes` — the pricing fetch succeeded but the book is empty (SX Bet or Hyperliquid with no resting orders; Kalshi provisional/multivariate markets whose quotes are empty-book placeholders). `unavailable` — the pricing enrichment fetch failed or timed out (SX Bet/Hyperliquid); identity fields are still served. */
+/**
+ * How completely — and how honestly — the pricing tier hydrated. It answers two questions in this precedence order: did every outcome get a price, and is any of those prices backed by a book you could actually cross.
+ *
+ * `live` — every outcome carries a price AND at least one outcome has a two-sided book the venue itself treats as quoted. **This is the only value that licenses reading `price` as a tradeable level.**
+ *
+ * `indicative` — every outcome carries a price, but no outcome has such a book behind it. The prices are marks, one side of a book with nothing facing it, or a two-sided book wider than the venue's own published spread threshold for that market. Concretely: an AlphaArcade market whose order book is empty, where the catalog midpoint is the only price left standing; a Predict market quoted 0.01 / 0.99, whose 0.5 midpoint is arithmetic rather than a market (Predict publishes a per-market `spreadThreshold` and this server honours it); a settled Polymarket market whose 1/0 `outcomePrices` are resolution marks; or a book with one resting order and nothing on the other side. `price` is still populated and still the venue's own number — treat it as roughly where the market is thought to be, never as a level you can trade or arbitrage against. **Filter or flag `indicative` before computing cross-venue edges**: an `indicative` 0.5 next to a `live` 0.735 elsewhere is not a 23¢ opportunity, it is one venue with no book.
+ *
+ * `partial` — some but not all outcomes priced. Incompleteness is reported ahead of quote quality because it is the louder warning, so a `partial` market says nothing about the book behind the prices it does carry.
+ *
+ * `no_quotes` — the pricing read succeeded and there is nothing at all: no book and no mark (SX Bet or Hyperliquid with no resting orders; Kalshi provisional/multivariate markets whose quotes are empty-book placeholders; AlphaArcade markets that have never traded). An empty book truthfully read is still an observation, so `observed_at` is populated.
+ *
+ * `unavailable` — the pricing enrichment fetch failed or timed out (SX Bet/Hyperliquid); identity fields are still served and `observed_at` is null.
+ */
 export declare const MarketDetailPricingAvailability: {
     readonly Live: "live";
+    readonly Indicative: "indicative";
     readonly Partial: "partial";
     readonly NoQuotes: "no_quotes";
     readonly Unavailable: "unavailable";

package/dist/api/types/MarketDetailPricingAvailability.js

@@ -1,7 +1,20 @@
 // This file was auto-generated by Fern from our API Definition.
-/** `live` — every outcome carries a price. `partial` — some but not all outcomes priced. `no_quotes` — the pricing fetch succeeded but the book is empty (SX Bet or Hyperliquid with no resting orders; Kalshi provisional/multivariate markets whose quotes are empty-book placeholders). `unavailable` — the pricing enrichment fetch failed or timed out (SX Bet/Hyperliquid); identity fields are still served. */
+/**
+ * How completely — and how honestly — the pricing tier hydrated. It answers two questions in this precedence order: did every outcome get a price, and is any of those prices backed by a book you could actually cross.
+ *
+ * `live` — every outcome carries a price AND at least one outcome has a two-sided book the venue itself treats as quoted. **This is the only value that licenses reading `price` as a tradeable level.**
+ *
+ * `indicative` — every outcome carries a price, but no outcome has such a book behind it. The prices are marks, one side of a book with nothing facing it, or a two-sided book wider than the venue's own published spread threshold for that market. Concretely: an AlphaArcade market whose order book is empty, where the catalog midpoint is the only price left standing; a Predict market quoted 0.01 / 0.99, whose 0.5 midpoint is arithmetic rather than a market (Predict publishes a per-market `spreadThreshold` and this server honours it); a settled Polymarket market whose 1/0 `outcomePrices` are resolution marks; or a book with one resting order and nothing on the other side. `price` is still populated and still the venue's own number — treat it as roughly where the market is thought to be, never as a level you can trade or arbitrage against. **Filter or flag `indicative` before computing cross-venue edges**: an `indicative` 0.5 next to a `live` 0.735 elsewhere is not a 23¢ opportunity, it is one venue with no book.
+ *
+ * `partial` — some but not all outcomes priced. Incompleteness is reported ahead of quote quality because it is the louder warning, so a `partial` market says nothing about the book behind the prices it does carry.
+ *
+ * `no_quotes` — the pricing read succeeded and there is nothing at all: no book and no mark (SX Bet or Hyperliquid with no resting orders; Kalshi provisional/multivariate markets whose quotes are empty-book placeholders; AlphaArcade markets that have never traded). An empty book truthfully read is still an observation, so `observed_at` is populated.
+ *
+ * `unavailable` — the pricing enrichment fetch failed or timed out (SX Bet/Hyperliquid); identity fields are still served and `observed_at` is null.
+ */
 export const MarketDetailPricingAvailability = {
     Live: "live",
+    Indicative: "indicative",
     Partial: "partial",
     NoQuotes: "no_quotes",
     Unavailable: "unavailable",

package/dist/api/types/MarketsListResponse.d.ts

@@ -2,6 +2,8 @@ import type * as PredictorSDK from "../index.js";
 export interface MarketsListResponse {
     /** Array of markets for the current page. */
     data: PredictorSDK.UnifiedMarket[];
+    /** Freshness of the catalog snapshot this page was served from. Describes the DATA; `pagination` describes the page. */
+    snapshot: PredictorSDK.MarketsSnapshot;
     /** Pagination metadata for the current page. */
     pagination: PredictorSDK.PaginationBlock;
 }

package/dist/api/types/MarketsSnapshot.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Freshness of the immutable catalog snapshot a `GET /v1/markets` page was served from. This endpoint reads a stored snapshot rather than calling the venues, so the age of the rows is not the age of the request.
+ */
+export interface MarketsSnapshot {
+    /**
+     * When PredictorSDK finished reading the OLDEST provider catalog contributing rows to this response — a conservative freshness floor for the whole page, in millisecond-precision ISO 8601.
+     *
+     * `observed_at` is a PredictorSDK read time, the same meaning it carries on `pricing.observed_at` and `trading_fees.observed_at`. The difference is WHICH read: those two stamp the upstream call this request made, while this one stamps the background ingestion crawl that built the snapshot, so it is normally minutes to hours old rather than milliseconds. It is not `as_of` because no venue published it.
+     *
+     * **It is a floor, not a single fact.** Providers are crawled on independent schedules, so the catalog is a merge of snapshots of different ages and one of them is the stalest. Narrow the response with `?provider=` to get that provider's own read time exactly — under a filter this field describes only the selected provider, the same way `pagination.total` does.
+     *
+     * Stable for an entire cursor traversal: a cursor stays bound to the snapshot that issued it, so every page of one traversal reports the identical value even while newer snapshots are published.
+     *
+     * `null` when the bound snapshot carries no read time. An unstamped provider makes the whole value null rather than being skipped, because reporting a newer floor than the data supports would let stale rows through a correct freshness bound.
+     */
+    observedAt: Date | null;
+}

package/dist/api/types/MarketsSnapshot.js

@@ -0,0 +1,2 @@
+// This file was auto-generated by Fern from our API Definition.
+export {};

package/dist/api/types/PlatformMarket.d.ts

@@ -13,6 +13,6 @@ export interface PlatformMarket {
     tokenIds?: string[];
     /** Source market ID. Present for platforms other than Kalshi and Polymarket. */
     marketId?: string;
-    /** Source outcome IDs. Present for platforms that use outcome IDs. */
+    /** Source outcome IDs for the market named by `market_id`, sorted and de-duplicated. These are the same values `GET /v1/markets/{market_id}` returns as `outcomes[].outcome_id`, so they join directly. SX Bet's are `outcomeOne`/`outcomeTwo` — market-scoped, because SX Bet publishes no per-outcome token; read them together with `market_id`. Present for platforms that use outcome IDs. */
     outcomeIds?: string[];
 }

package/dist/api/types/UnifiedMarket.d.ts

@@ -1,6 +1,6 @@
 import type * as PredictorSDK from "../index.js";
 export interface UnifiedMarket {
-    /** Composite market identifier in the format `{provider}:{provider_id}` (e.g. `kalshi:KXNBAGAME-26MAR06INDLAL-LAL`). */
+    /** Composite market identifier in the format `{provider}:{provider_id}` (e.g. `kalshi:AMAZONFTC-29DEC31`). */
     id: string;
     /** Prediction market provider. */
     provider: PredictorSDK.UnifiedMarketProvider;

package/dist/api/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./AmbiguousIdentifierError.js";
 export * from "./CanonicalSportsEvent.js";
 export * from "./CanonicalSportsOutcome.js";
 export * from "./CanonicalSportsParticipant.js";
@@ -18,6 +19,7 @@ export * from "./EventResponse.js";
 export * from "./EventResponsePlatform.js";
 export * from "./GetEventRequestPlatform.js";
 export * from "./GetMarketRequestPlatform.js";
+export * from "./GetMarketsRequestProvider.js";
 export * from "./MarketCategory.js";
 export * from "./MarketDetailFeeLeg.js";
 export * from "./MarketDetailFeeLegModel.js";
@@ -25,6 +27,7 @@ export * from "./MarketDetailFeeRounding.js";
 export * from "./MarketDetailFeeRoundingDirection.js";
 export * from "./MarketDetailOutcome.js";
 export * from "./MarketDetailPricing.js";
+export * from "./MarketDetailPricingAsOfKind.js";
 export * from "./MarketDetailPricingAvailability.js";
 export * from "./MarketDetailPricingScale.js";
 export * from "./MarketDetailPricingSource.js";
@@ -37,6 +40,7 @@ export * from "./MarketDetailTradingFeesAvailability.js";
 export * from "./MarketDetailTradingFeesChargeBasis.js";
 export * from "./MarketDetailTradingFeesSource.js";
 export * from "./MarketsListResponse.js";
+export * from "./MarketsSnapshot.js";
 export * from "./PaginationBlock.js";
 export * from "./PaymentRequiredErrorAction.js";
 export * from "./PaymentRequiredErrorBody.js";

package/dist/api/types/index.js

@@ -1,3 +1,4 @@
+export * from "./AmbiguousIdentifierError.js";
 export * from "./CanonicalSportsEvent.js";
 export * from "./CanonicalSportsOutcome.js";
 export * from "./CanonicalSportsParticipant.js";
@@ -18,6 +19,7 @@ export * from "./EventResponse.js";
 export * from "./EventResponsePlatform.js";
 export * from "./GetEventRequestPlatform.js";
 export * from "./GetMarketRequestPlatform.js";
+export * from "./GetMarketsRequestProvider.js";
 export * from "./MarketCategory.js";
 export * from "./MarketDetailFeeLeg.js";
 export * from "./MarketDetailFeeLegModel.js";
@@ -25,6 +27,7 @@ export * from "./MarketDetailFeeRounding.js";
 export * from "./MarketDetailFeeRoundingDirection.js";
 export * from "./MarketDetailOutcome.js";
 export * from "./MarketDetailPricing.js";
+export * from "./MarketDetailPricingAsOfKind.js";
 export * from "./MarketDetailPricingAvailability.js";
 export * from "./MarketDetailPricingScale.js";
 export * from "./MarketDetailPricingSource.js";
@@ -37,6 +40,7 @@ export * from "./MarketDetailTradingFeesAvailability.js";
 export * from "./MarketDetailTradingFeesChargeBasis.js";
 export * from "./MarketDetailTradingFeesSource.js";
 export * from "./MarketsListResponse.js";
+export * from "./MarketsSnapshot.js";
 export * from "./PaginationBlock.js";
 export * from "./PaymentRequiredErrorAction.js";
 export * from "./PaymentRequiredErrorBody.js";

package/dist/serialization/types/AmbiguousIdentifierError.d.ts

@@ -0,0 +1,12 @@
+import type * as PredictorSDK from "../../api/index.js";
+import * as core from "../../core/index.js";
+import type * as serializers from "../index.js";
+export declare const AmbiguousIdentifierError: core.serialization.ObjectSchema<serializers.AmbiguousIdentifierError.Raw, PredictorSDK.AmbiguousIdentifierError>;
+export declare namespace AmbiguousIdentifierError {
+    interface Raw {
+        error: string;
+        message?: string | null;
+        candidates: string[];
+        status_code: number;
+    }
+}

package/dist/serialization/types/AmbiguousIdentifierError.js

@@ -0,0 +1,8 @@
+// This file was auto-generated by Fern from our API Definition.
+import * as core from "../../core/index.js";
+export const AmbiguousIdentifierError = core.serialization.object({
+    error: core.serialization.string(),
+    message: core.serialization.string().optional(),
+    candidates: core.serialization.list(core.serialization.string()),
+    statusCode: core.serialization.property("status_code", core.serialization.number()),
+});

package/dist/serialization/types/GetMarketsRequestProvider.d.ts

@@ -0,0 +1,7 @@
+import type * as PredictorSDK from "../../api/index.js";
+import * as core from "../../core/index.js";
+import type * as serializers from "../index.js";
+export declare const GetMarketsRequestProvider: core.serialization.Schema<serializers.GetMarketsRequestProvider.Raw, PredictorSDK.GetMarketsRequestProvider>;
+export declare namespace GetMarketsRequestProvider {
+    type Raw = "kalshi" | "polymarket" | "predict" | "sxbet" | "hyperliquid" | "alpha-arcade";
+}

package/dist/serialization/types/GetMarketsRequestProvider.js

@@ -0,0 +1,3 @@
+// This file was auto-generated by Fern from our API Definition.
+import * as core from "../../core/index.js";
+export const GetMarketsRequestProvider = core.serialization.enum_(["kalshi", "polymarket", "predict", "sxbet", "hyperliquid", "alpha-arcade"]);

package/dist/serialization/types/MarketDetailPricing.d.ts

@@ -1,6 +1,7 @@
 import type * as PredictorSDK from "../../api/index.js";
 import * as core from "../../core/index.js";
 import type * as serializers from "../index.js";
+import { MarketDetailPricingAsOfKind } from "./MarketDetailPricingAsOfKind.js";
 import { MarketDetailPricingAvailability } from "./MarketDetailPricingAvailability.js";
 import { MarketDetailPricingScale } from "./MarketDetailPricingScale.js";
 import { MarketDetailPricingSource } from "./MarketDetailPricingSource.js";
@@ -11,6 +12,8 @@ export declare namespace MarketDetailPricing {
         scale: MarketDetailPricingScale.Raw;
         source: MarketDetailPricingSource.Raw;
         as_of?: string | null;
+        as_of_kind: MarketDetailPricingAsOfKind.Raw;
+        observed_at?: string | null;
         neg_risk?: boolean | null;
     }
 }

package/dist/serialization/types/MarketDetailPricing.js

@@ -1,5 +1,6 @@
 // This file was auto-generated by Fern from our API Definition.
 import * as core from "../../core/index.js";
+import { MarketDetailPricingAsOfKind } from "./MarketDetailPricingAsOfKind.js";
 import { MarketDetailPricingAvailability } from "./MarketDetailPricingAvailability.js";
 import { MarketDetailPricingScale } from "./MarketDetailPricingScale.js";
 import { MarketDetailPricingSource } from "./MarketDetailPricingSource.js";
@@ -8,5 +9,7 @@ export const MarketDetailPricing = core.serialization.object({
     scale: MarketDetailPricingScale,
     source: MarketDetailPricingSource,
     asOf: core.serialization.property("as_of", core.serialization.date().nullable()),
+    asOfKind: core.serialization.property("as_of_kind", MarketDetailPricingAsOfKind),
+    observedAt: core.serialization.property("observed_at", core.serialization.date().nullable()),
     negRisk: core.serialization.property("neg_risk", core.serialization.boolean().optional()),
 });

package/dist/serialization/types/MarketDetailPricingAsOfKind.d.ts

@@ -0,0 +1,7 @@
+import type * as PredictorSDK from "../../api/index.js";
+import * as core from "../../core/index.js";
+import type * as serializers from "../index.js";
+export declare const MarketDetailPricingAsOfKind: core.serialization.Schema<serializers.MarketDetailPricingAsOfKind.Raw, PredictorSDK.MarketDetailPricingAsOfKind>;
+export declare namespace MarketDetailPricingAsOfKind {
+    type Raw = "quote" | "record_refresh" | "record_static" | "unknown";
+}

package/dist/serialization/types/MarketDetailPricingAsOfKind.js

@@ -0,0 +1,3 @@
+// This file was auto-generated by Fern from our API Definition.
+import * as core from "../../core/index.js";
+export const MarketDetailPricingAsOfKind = core.serialization.enum_(["quote", "record_refresh", "record_static", "unknown"]);

package/dist/serialization/types/MarketDetailPricingAvailability.d.ts

@@ -3,5 +3,5 @@ import * as core from "../../core/index.js";
 import type * as serializers from "../index.js";
 export declare const MarketDetailPricingAvailability: core.serialization.Schema<serializers.MarketDetailPricingAvailability.Raw, PredictorSDK.MarketDetailPricingAvailability>;
 export declare namespace MarketDetailPricingAvailability {
-    type Raw = "live" | "partial" | "no_quotes" | "unavailable";
+    type Raw = "live" | "indicative" | "partial" | "no_quotes" | "unavailable";
 }

package/dist/serialization/types/MarketDetailPricingAvailability.js

@@ -1,3 +1,3 @@
 // This file was auto-generated by Fern from our API Definition.
 import * as core from "../../core/index.js";
-export const MarketDetailPricingAvailability = core.serialization.enum_(["live", "partial", "no_quotes", "unavailable"]);
+export const MarketDetailPricingAvailability = core.serialization.enum_(["live", "indicative", "partial", "no_quotes", "unavailable"]);

package/dist/serialization/types/MarketsListResponse.d.ts

@@ -1,12 +1,14 @@
 import type * as PredictorSDK from "../../api/index.js";
 import * as core from "../../core/index.js";
 import type * as serializers from "../index.js";
+import { MarketsSnapshot } from "./MarketsSnapshot.js";
 import { PaginationBlock } from "./PaginationBlock.js";
 import { UnifiedMarket } from "./UnifiedMarket.js";
 export declare const MarketsListResponse: core.serialization.ObjectSchema<serializers.MarketsListResponse.Raw, PredictorSDK.MarketsListResponse>;
 export declare namespace MarketsListResponse {
     interface Raw {
         data: UnifiedMarket.Raw[];
+        snapshot: MarketsSnapshot.Raw;
         pagination: PaginationBlock.Raw;
     }
 }

package/dist/serialization/types/MarketsListResponse.js

@@ -1,8 +1,10 @@
 // This file was auto-generated by Fern from our API Definition.
 import * as core from "../../core/index.js";
+import { MarketsSnapshot } from "./MarketsSnapshot.js";
 import { PaginationBlock } from "./PaginationBlock.js";
 import { UnifiedMarket } from "./UnifiedMarket.js";
 export const MarketsListResponse = core.serialization.object({
     data: core.serialization.list(UnifiedMarket),
+    snapshot: MarketsSnapshot,
     pagination: PaginationBlock,
 });

package/dist/serialization/types/MarketsSnapshot.d.ts

@@ -0,0 +1,9 @@
+import type * as PredictorSDK from "../../api/index.js";
+import * as core from "../../core/index.js";
+import type * as serializers from "../index.js";
+export declare const MarketsSnapshot: core.serialization.ObjectSchema<serializers.MarketsSnapshot.Raw, PredictorSDK.MarketsSnapshot>;
+export declare namespace MarketsSnapshot {
+    interface Raw {
+        observed_at?: string | null;
+    }
+}

package/dist/serialization/types/MarketsSnapshot.js

@@ -0,0 +1,5 @@
+// This file was auto-generated by Fern from our API Definition.
+import * as core from "../../core/index.js";
+export const MarketsSnapshot = core.serialization.object({
+    observedAt: core.serialization.property("observed_at", core.serialization.date().nullable()),
+});

package/dist/serialization/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./AmbiguousIdentifierError.js";
 export * from "./CanonicalSportsEvent.js";
 export * from "./CanonicalSportsOutcome.js";
 export * from "./CanonicalSportsParticipant.js";
@@ -18,6 +19,7 @@ export * from "./EventResponse.js";
 export * from "./EventResponsePlatform.js";
 export * from "./GetEventRequestPlatform.js";
 export * from "./GetMarketRequestPlatform.js";
+export * from "./GetMarketsRequestProvider.js";
 export * from "./MarketCategory.js";
 export * from "./MarketDetailFeeLeg.js";
 export * from "./MarketDetailFeeLegModel.js";
@@ -25,6 +27,7 @@ export * from "./MarketDetailFeeRounding.js";
 export * from "./MarketDetailFeeRoundingDirection.js";
 export * from "./MarketDetailOutcome.js";
 export * from "./MarketDetailPricing.js";
+export * from "./MarketDetailPricingAsOfKind.js";
 export * from "./MarketDetailPricingAvailability.js";
 export * from "./MarketDetailPricingScale.js";
 export * from "./MarketDetailPricingSource.js";
@@ -37,6 +40,7 @@ export * from "./MarketDetailTradingFeesAvailability.js";
 export * from "./MarketDetailTradingFeesChargeBasis.js";
 export * from "./MarketDetailTradingFeesSource.js";
 export * from "./MarketsListResponse.js";
+export * from "./MarketsSnapshot.js";
 export * from "./PaginationBlock.js";
 export * from "./PaymentRequiredErrorAction.js";
 export * from "./PaymentRequiredErrorBody.js";

package/dist/serialization/types/index.js

@@ -1,3 +1,4 @@
+export * from "./AmbiguousIdentifierError.js";
 export * from "./CanonicalSportsEvent.js";
 export * from "./CanonicalSportsOutcome.js";
 export * from "./CanonicalSportsParticipant.js";
@@ -18,6 +19,7 @@ export * from "./EventResponse.js";
 export * from "./EventResponsePlatform.js";
 export * from "./GetEventRequestPlatform.js";
 export * from "./GetMarketRequestPlatform.js";
+export * from "./GetMarketsRequestProvider.js";
 export * from "./MarketCategory.js";
 export * from "./MarketDetailFeeLeg.js";
 export * from "./MarketDetailFeeLegModel.js";
@@ -25,6 +27,7 @@ export * from "./MarketDetailFeeRounding.js";
 export * from "./MarketDetailFeeRoundingDirection.js";
 export * from "./MarketDetailOutcome.js";
 export * from "./MarketDetailPricing.js";
+export * from "./MarketDetailPricingAsOfKind.js";
 export * from "./MarketDetailPricingAvailability.js";
 export * from "./MarketDetailPricingScale.js";
 export * from "./MarketDetailPricingSource.js";
@@ -37,6 +40,7 @@ export * from "./MarketDetailTradingFeesAvailability.js";
 export * from "./MarketDetailTradingFeesChargeBasis.js";
 export * from "./MarketDetailTradingFeesSource.js";
 export * from "./MarketsListResponse.js";
+export * from "./MarketsSnapshot.js";
 export * from "./PaginationBlock.js";
 export * from "./PaymentRequiredErrorAction.js";
 export * from "./PaymentRequiredErrorBody.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@predictorsdk/client",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "The official TypeScript/JavaScript client for the PredictorSDK matching markets API",
   "license": "MIT",
   "keywords": [