pmxt-core 2.47.0 → 2.48.0

package/dist/BaseExchange.d.ts

@@ -1,6 +1,6 @@
 import { AxiosInstance } from 'axios';
 import { SubscribedAddressSnapshot, SubscriptionOption } from './subscriber/base';
-import { Balance, BuiltOrder, CandleInterval, CreateOrderParams, Order, OrderBook, Position, PriceCandle, Trade, UnifiedEvent, UnifiedMarket, UserTrade } from './types';
+import { Balance, BuiltOrder, CandleInterval, CreateOrderParams, Order, OrderBook, Position, PriceCandle, Trade, UnifiedEvent, UnifiedMarket, UnifiedSeries, UserTrade } from './types';
 import { ExecutionPriceResult } from './utils/math';
 import type { FetchMarketMatchesParams, FetchMatchesParams, FetchEventMatchesParams, FetchArbitrageParams, FetchMatchedMarketsParams, FetchMatchedPricesParams, MatchResult, EventMatchResult, PriceComparison, ArbitrageOpportunity, MatchedMarketPair, MatchedPricePair } from './router/types';
 export interface ApiEndpoint {
@@ -74,6 +74,8 @@ export interface EventFetchParams {
     searchIn?: 'title' | 'description' | 'both';
     eventId?: string;
     slug?: string;
+    /** Filter events by their parent series. Accepts the venue-native series id / ticker / slug (e.g. Kalshi `"KXATPMATCH"`, Polymarket `"wta"`). Passed through to the vendor where supported, otherwise applied to `sourceMetadata` after fetch. */
+    series?: string;
     /** Optional client-side filter applied after fetching */
     filter?: EventFilterCriteria;
     /** Filter by category. Each event belongs to a venue-assigned category such as "Sports", "Politics", "Crypto", "Bitcoin", "Soccer", "Economic Policy" (Polymarket) or "Sports", "Mentions" (Kalshi). */
@@ -81,6 +83,24 @@ export interface EventFetchParams {
     /** Filter by tags. Returns events matching ANY of the provided tags. Tags are more specific than categories -- for example a "Politics" event might carry tags ["Politics", "Geopolitics", "Middle East", "Iran"]. Common tags include "Crypto", "Elections", "Fed Rates", "FIFA World Cup", "Trump". */
     tags?: string[];
 }
+/**
+ * Parameters for `fetchSeries`. Venues that don't expose a series concept
+ * return an empty array regardless of the filters.
+ */
+export interface SeriesFetchParams {
+    /** Direct lookup by venue-native series id (e.g. "KXATPMATCH" on Kalshi, "atp" or "1" on Polymarket Gamma). When set, the result is the matching series with its events populated where the venue supports it. */
+    id?: string;
+    /** Lookup by series slug (e.g. "wta", "nfl"). */
+    slug?: string;
+    /** Keyword search across series title / description. */
+    query?: string;
+    /** Filter by recurrence cadence ('daily', 'weekly', 'annual', ...). */
+    recurrence?: string;
+    /** Maximum number of results to return. */
+    limit?: number;
+    /** Pagination offset. */
+    offset?: number;
+}
 /**
  * Deprecated - use OHLCVParams or TradesParams instead. Resolution is optional for backward compatibility.
  */
@@ -219,6 +239,8 @@ export interface ExchangeHas {
     fetchMarkets: ExchangeCapability;
     /** Whether this exchange supports fetching events. */
     fetchEvents: ExchangeCapability;
+    /** Whether this exchange exposes a recurring-series concept (Series -> Event -> Market -> Outcome). Venues without one return `false` and an empty array from `fetchSeries`. */
+    fetchSeries: ExchangeCapability;
     /** Whether this exchange supports fetching OHLCV candles. */
     fetchOHLCV: ExchangeCapability;
     /** Whether this exchange supports fetching the order book. */
@@ -451,6 +473,18 @@ export declare abstract class PredictionMarketExchange {
      * @note Some exchanges (like Limitless) may only support status 'active' for search results.
      */
     fetchEvents(params?: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * Fetch the recurring series (fourth tier above Event -> Market -> Outcome)
+     * that this venue exposes. Returns an empty array on venues without a
+     * series concept (Limitless, Smarkets, Probable, Metaculus, Baozi,
+     * Hyperliquid, SuiBets, Polymarket US).
+     *
+     * - `params.id` -> a single matching series with its events populated where supported.
+     * - no params -> the full list, typically without nested events for payload size.
+     *
+     * @returns Array of unified series. Always an array, including the singular-lookup case.
+     */
+    fetchSeries(params?: SeriesFetchParams): Promise<UnifiedSeries[]>;
     /**
      * Fetch a single market by lookup parameters.
      * Convenience wrapper around fetchMarkets() that returns a single result or throws MarketNotFound.
@@ -782,6 +816,13 @@ export declare abstract class PredictionMarketExchange {
      * Implementation for searching events by keyword.
      */
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * @internal
+     * Implementation for fetching recurring series. Override in venue adapters
+     * that expose a series concept; the default returns an empty array so
+     * venues without one are silently a no-op.
+     */
+    protected fetchSeriesImpl(_params: SeriesFetchParams): Promise<UnifiedSeries[]>;
     /**
      * Call an implicit API method by its operationId (or auto-generated name).
      * Provides a typed entry point so unified methods can delegate to the implicit API

package/dist/BaseExchange.js

@@ -361,6 +361,23 @@ class PredictionMarketExchange {
         const start = offset ?? 0;
         return limit !== undefined ? events.slice(start, start + limit) : events.slice(start);
     }
+    /**
+     * Fetch the recurring series (fourth tier above Event -> Market -> Outcome)
+     * that this venue exposes. Returns an empty array on venues without a
+     * series concept (Limitless, Smarkets, Probable, Metaculus, Baozi,
+     * Hyperliquid, SuiBets, Polymarket US).
+     *
+     * - `params.id` -> a single matching series with its events populated where supported.
+     * - no params -> the full list, typically without nested events for payload size.
+     *
+     * @returns Array of unified series. Always an array, including the singular-lookup case.
+     */
+    async fetchSeries(params) {
+        const { limit, offset, ...venueParams } = params ?? {};
+        const series = await this.fetchSeriesImpl(venueParams);
+        const start = offset ?? 0;
+        return limit !== undefined ? series.slice(start, start + limit) : series.slice(start);
+    }
     /**
      * Fetch a single market by lookup parameters.
      * Convenience wrapper around fetchMarkets() that returns a single result or throws MarketNotFound.
@@ -1056,6 +1073,15 @@ class PredictionMarketExchange {
     async fetchEventsImpl(params) {
         throw new Error("Method fetchEventsImpl not implemented.");
     }
+    /**
+     * @internal
+     * Implementation for fetching recurring series. Override in venue adapters
+     * that expose a series concept; the default returns an empty array so
+     * venues without one are silently a no-op.
+     */
+    async fetchSeriesImpl(_params) {
+        return [];
+    }
     /**
      * Call an implicit API method by its operationId (or auto-generated name).
      * Provides a typed entry point so unified methods can delegate to the implicit API
@@ -1163,7 +1189,7 @@ class PredictionMarketExchange {
     // ----------------------------------------------------------------------------
     /** All keys that appear in ExchangeHas -- kept in sync via the exhaustive check below. */
     static _capabilityKeys = [
-        'fetchMarkets', 'fetchEvents', 'fetchOHLCV', 'fetchOrderBook', 'fetchOrderBooks',
+        'fetchMarkets', 'fetchEvents', 'fetchSeries', 'fetchOHLCV', 'fetchOrderBook', 'fetchOrderBooks',
         'fetchTrades', 'createOrder', 'cancelOrder', 'fetchOrder',
         'fetchOpenOrders', 'fetchPositions', 'fetchBalance',
         'watchAddress', 'unwatchAddress', 'watchOrderBook', 'watchOrderBooks',
@@ -1175,7 +1201,7 @@ class PredictionMarketExchange {
     // Compile-time exhaustiveness check: fails tsc if a key exists in
     // ExchangeHas but is missing from _capabilityKeys above.
     static _exhaustiveCheck = {
-        fetchMarkets: true, fetchEvents: true, fetchOHLCV: true,
+        fetchMarkets: true, fetchEvents: true, fetchSeries: true, fetchOHLCV: true,
         fetchOrderBook: true, fetchOrderBooks: true, fetchTrades: true, createOrder: true,
         cancelOrder: true, fetchOrder: true, fetchOpenOrders: true,
         fetchPositions: true, fetchBalance: true, watchAddress: true,
@@ -1194,6 +1220,7 @@ class PredictionMarketExchange {
     static _capabilityDelegates = {
         fetchMarkets: 'fetchMarketsImpl',
         fetchEvents: 'fetchEventsImpl',
+        fetchSeries: 'fetchSeriesImpl',
         watchOrderBooks: 'watchOrderBook',
         fetchMatches: 'fetchMarketMatches',
         fetchHedges: 'fetchRelatedMarkets',

package/dist/exchanges/baozi/index.d.ts

@@ -12,6 +12,7 @@ export declare class BaoziExchange extends PredictionMarketExchange {
         fetchOpenOrders: "emulated";
         cancelOrder: false;
         watchTrades: false;
+        fetchSeries: false;
     };
     private auth?;
     private connection;

package/dist/exchanges/baozi/index.js

@@ -19,6 +19,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchOpenOrders: 'emulated',
         cancelOrder: false,
         watchTrades: false,
+        fetchSeries: false,
     };
     auth;
     connection;
@@ -59,6 +60,10 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         return this.normalizer.normalizeMarkets(rawMarkets, params);
     }
     async fetchEventsImpl(params) {
+        // Venue does not expose a series concept; honoring `params.series` by returning [] rather than ignoring the filter.
+        if (params.series !== undefined) {
+            return [];
+        }
         const rawMarkets = await this.fetcher.fetchRawEvents(params);
         return this.normalizer.normalizeEvents(rawMarkets, {
             query: params.query,

package/dist/exchanges/gemini-titan/index.d.ts

@@ -1,5 +1,5 @@
-import { PredictionMarketExchange, MarketFilterParams, EventFetchParams, ExchangeCredentials } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, OrderBook, Trade, Order, Position, CreateOrderParams, BuiltOrder } from '../../types';
+import { PredictionMarketExchange, MarketFilterParams, EventFetchParams, SeriesFetchParams, ExchangeCredentials } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, UnifiedSeries, OrderBook, Trade, Order, Position, CreateOrderParams, BuiltOrder } from '../../types';
 export interface GeminiTitanExchangeOptions {
     credentials?: ExchangeCredentials;
     sandbox?: boolean;
@@ -10,11 +10,15 @@ export declare class GeminiTitanExchange extends PredictionMarketExchange {
     private readonly normalizer;
     private readonly geminiAuth?;
     private geminiWs?;
+    protected readonly capabilityOverrides: {
+        fetchSeries: "emulated";
+    };
     constructor(credentials?: ExchangeCredentials | GeminiTitanExchangeOptions);
     get name(): string;
     private requireAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    protected fetchSeriesImpl(params: SeriesFetchParams): Promise<UnifiedSeries[]>;
     fetchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
     buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
     submitOrder(built: BuiltOrder): Promise<Order>;

package/dist/exchanges/gemini-titan/index.js

@@ -16,6 +16,9 @@ class GeminiTitanExchange extends BaseExchange_1.PredictionMarketExchange {
     normalizer;
     geminiAuth;
     geminiWs;
+    capabilityOverrides = {
+        fetchSeries: 'emulated',
+    };
     constructor(credentials) {
         const opts = credentials && 'credentials' in credentials
             ? credentials
@@ -63,10 +66,87 @@ class GeminiTitanExchange extends BaseExchange_1.PredictionMarketExchange {
     }
     async fetchEventsImpl(params) {
         const rawEvents = await this.fetcher.fetchRawEvents(params);
-        return rawEvents
+        let filtered = rawEvents;
+        // Client-side series filter: keep only events whose series id matches.
+        if (params.series) {
+            const seriesId = params.series;
+            filtered = rawEvents.filter((e) => {
+                if (e.series == null)
+                    return false;
+                const s = e.series;
+                const id = String(s['id'] ?? s['ticker'] ?? s['symbol'] ?? '');
+                return id === seriesId;
+            });
+        }
+        return filtered
             .map(e => this.normalizer.normalizeEventWithMarkets(e))
             .filter((e) => e !== null);
     }
+    async fetchSeriesImpl(params) {
+        // Gemini-Titan has no dedicated /series endpoint. Derive the catalog by
+        // fetching all events and grouping by the series id in event.series.
+        const rawEvents = await this.fetcher.fetchRawEvents({});
+        // Build a map from series id -> { rawSeries, rawEvents[] }
+        const seriesMap = new Map();
+        for (const event of rawEvents) {
+            if (event.series == null)
+                continue;
+            const s = event.series;
+            const id = String(s['id'] ?? s['ticker'] ?? s['symbol'] ?? '');
+            if (!id)
+                continue;
+            const existing = seriesMap.get(id);
+            if (existing) {
+                existing.raws.push(event);
+            }
+            else {
+                seriesMap.set(id, { raw: s, raws: [event] });
+            }
+        }
+        let entries = Array.from(seriesMap.entries()).map(([id, v]) => ({
+            id,
+            raw: v.raw,
+            raws: v.raws,
+        }));
+        // Apply params.id filter
+        if (params.id) {
+            entries = entries.filter((e) => e.id === params.id);
+        }
+        // Apply params.slug filter (treat slug same as id for Gemini series)
+        if (params.slug) {
+            const slug = params.slug;
+            entries = entries.filter((e) => {
+                const rawSlug = e.raw['slug'] != null ? String(e.raw['slug']) : e.id;
+                return rawSlug === slug;
+            });
+        }
+        // Apply params.query filter (title match)
+        if (params.query) {
+            const lowerQuery = params.query.toLowerCase();
+            entries = entries.filter((e) => {
+                const title = String(e.raw['title'] ?? e.raw['name'] ?? '');
+                return title.toLowerCase().includes(lowerQuery);
+            });
+        }
+        // Apply params.recurrence filter
+        if (params.recurrence) {
+            const recurrence = params.recurrence;
+            entries = entries.filter((e) => {
+                const freq = e.raw['frequency'] ?? e.raw['recurrence'];
+                return freq != null && String(freq) === recurrence;
+            });
+        }
+        return entries.map((e) => {
+            let events;
+            // When fetching by id, populate the events field.
+            if (params.id) {
+                events = e.raws
+                    .map((raw) => this.normalizer.normalizeEventWithMarkets(raw))
+                    .filter((ev) => ev !== null);
+            }
+            return this.normalizer.normalizeSeries(e.raw, events);
+        });
+    }
     async fetchOrderBook(outcomeId, _limit, _params) {
         const resolved = await this.resolveOutcomeAlias(outcomeId, _params);
         outcomeId = resolved.outcomeId;

package/dist/exchanges/gemini-titan/normalizer.d.ts

@@ -1,10 +1,16 @@
-import { UnifiedMarket, UnifiedEvent, OrderBook, Order, Position } from '../../types';
+import { UnifiedMarket, UnifiedEvent, UnifiedSeries, OrderBook, Order, Position } from '../../types';
 import { IExchangeNormalizer } from '../interfaces';
 import { GeminiRawEvent, GeminiRawContract, GeminiRawOrder, GeminiRawPosition, GeminiRawOrderBook } from './types';
 export declare class GeminiNormalizer implements IExchangeNormalizer<GeminiRawEvent, GeminiRawEvent> {
     normalizeMarket(raw: GeminiRawEvent): UnifiedMarket | null;
     normalizeEvent(raw: GeminiRawEvent): UnifiedEvent | null;
     normalizeEventWithMarkets(raw: GeminiRawEvent): UnifiedEvent | null;
+    /**
+     * Produce a UnifiedSeries from a Gemini `series` object (raw Record).
+     * The series id is taken from the first non-null of: id, ticker, symbol.
+     * `events` is optionally injected by the caller when doing a single-id lookup.
+     */
+    normalizeSeries(raw: Record<string, unknown>, events?: UnifiedEvent[]): UnifiedSeries;
     normalizeMarketsFromEvent(raw: GeminiRawEvent): UnifiedMarket[];
     normalizeContract(contract: GeminiRawContract, event: GeminiRawEvent): UnifiedMarket | null;
     normalizeOrderBook(raw: GeminiRawOrderBook, _outcomeId: string): OrderBook;

package/dist/exchanges/gemini-titan/normalizer.js

@@ -141,6 +141,29 @@ class GeminiNormalizer {
             volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
         };
     }
+    /**
+     * Produce a UnifiedSeries from a Gemini `series` object (raw Record).
+     * The series id is taken from the first non-null of: id, ticker, symbol.
+     * `events` is optionally injected by the caller when doing a single-id lookup.
+     */
+    normalizeSeries(raw, events) {
+        const id = String(raw['id'] ?? raw['ticker'] ?? raw['symbol'] ?? '');
+        const ticker = raw['ticker'] != null ? String(raw['ticker']) : undefined;
+        const title = String(raw['title'] ?? raw['name'] ?? id);
+        const recurrence = raw['frequency'] != null
+            ? String(raw['frequency'])
+            : raw['recurrence'] != null
+                ? String(raw['recurrence'])
+                : null;
+        return {
+            id,
+            ticker,
+            title,
+            recurrence,
+            events,
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, ['id', 'ticker', 'title', 'name', 'frequency', 'recurrence']),
+        };
+    }
     normalizeMarketsFromEvent(raw) {
         const markets = [];
         for (const contract of raw.contracts) {

package/dist/exchanges/hyperliquid/index.d.ts

@@ -5,6 +5,9 @@ export interface HyperliquidExchangeOptions {
     testnet?: boolean;
 }
 export declare class HyperliquidExchange extends PredictionMarketExchange {
+    protected readonly capabilityOverrides: {
+        fetchSeries: false;
+    };
     private readonly config;
     private readonly fetcher;
     private readonly normalizer;

package/dist/exchanges/hyperliquid/index.js

@@ -9,6 +9,9 @@ const normalizer_1 = require("./normalizer");
 const auth_1 = require("./auth");
 const errors_2 = require("./errors");
 class HyperliquidExchange extends BaseExchange_1.PredictionMarketExchange {
+    capabilityOverrides = {
+        fetchSeries: false,
+    };
     config;
     fetcher;
     normalizer;
@@ -69,6 +72,10 @@ class HyperliquidExchange extends BaseExchange_1.PredictionMarketExchange {
             .filter((m) => m !== null);
     }
     async fetchEventsImpl(params) {
+        // Venue does not expose a series concept; honoring `params.series` by returning [] rather than ignoring the filter.
+        if (params.series !== undefined) {
+            return [];
+        }
         const [rawQuestions, meta, mids] = await Promise.all([
             this.fetcher.fetchRawEvents(params),
             this.fetcher.fetchOutcomeMeta(),

package/dist/exchanges/kalshi/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-05-30T12:19:28.168Z
+ * Generated at: 2026-05-30T13:35:15.520Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {

package/dist/exchanges/kalshi/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kalshiApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-05-30T12:19:28.168Z
+ * Generated at: 2026-05-30T13:35:15.520Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

package/dist/exchanges/kalshi/fetcher.d.ts

@@ -44,6 +44,14 @@ interface KalshiSeriesInfo {
     title?: string;
     tags?: string[];
 }
+export interface KalshiRawSeries {
+    ticker: string;
+    title?: string;
+    tags?: string[];
+    frequency?: string;
+    category?: string;
+    [key: string]: unknown;
+}
 export interface KalshiRawEventPage {
     events: KalshiRawEvent[];
     cursor?: string | null;
@@ -153,6 +161,7 @@ export declare class KalshiFetcher implements IExchangeFetcher<KalshiRawEvent, K
     }>;
     fetchRawOrders(queryParams: Record<string, any>): Promise<KalshiRawOrder[]>;
     fetchRawHistoricalOrders(queryParams: Record<string, any>): Promise<KalshiRawOrder[]>;
+    fetchRawSeriesList(): Promise<KalshiRawSeries[]>;
     fetchRawSeriesMap(): Promise<Map<string, KalshiSeriesInfo>>;
     fetchRawEventByTicker(eventTicker: string): Promise<KalshiRawEvent[]>;
     private fetchRawEventsDefault;
@@ -160,6 +169,7 @@ export declare class KalshiFetcher implements IExchangeFetcher<KalshiRawEvent, K
     private enrichEventsWithSeriesMap;
     private fetchActiveEvents;
     private fetchAllWithStatus;
+    private fetchAllWithSeriesTicker;
     private fetchPageWithStatus;
 }
 export {};

package/dist/exchanges/kalshi/fetcher.js

@@ -58,6 +58,11 @@ class KalshiFetcher {
             if (params.slug) {
                 return this.fetchRawEventByTicker(params.slug);
             }
+            // When a series filter is present, delegate to server-side filtering so
+            // only events belonging to that series are returned — no double-filtering.
+            if (params.series) {
+                return this.fetchAllWithSeriesTicker(params.series);
+            }
             const status = params?.status || 'active';
             if (status === 'all') {
                 const [openEvents, closedEvents, settledEvents] = await Promise.all([
@@ -213,6 +218,15 @@ class KalshiFetcher {
         const data = await this.ctx.callApi('GetHistoricalOrders', queryParams);
         return data.orders || [];
     }
+    async fetchRawSeriesList() {
+        try {
+            const data = await this.ctx.callApi('GetSeriesList');
+            return (data.series || []);
+        }
+        catch (e) {
+            throw errors_1.kalshiErrorMapper.mapError(e);
+        }
+    }
     async fetchRawSeriesMap() {
         try {
             const data = await this.ctx.callApi('GetSeriesList');
@@ -381,6 +395,28 @@ class KalshiFetcher {
         } while (cursor && page < MAX_PAGES);
         return allEvents;
     }
+    async fetchAllWithSeriesTicker(seriesTicker) {
+        let allEvents = [];
+        let cursor = null;
+        let page = 0;
+        do {
+            const queryParams = {
+                series_ticker: seriesTicker,
+                with_nested_markets: true,
+                limit: BATCH_SIZE,
+            };
+            if (cursor)
+                queryParams.cursor = cursor;
+            const data = await this.ctx.callApi('GetEvents', queryParams);
+            const events = data.events || [];
+            if (events.length === 0)
+                break;
+            allEvents = [...allEvents, ...events];
+            cursor = data.cursor;
+            page++;
+        } while (cursor && page < MAX_PAGES);
+        return allEvents;
+    }
     async fetchPageWithStatus(apiStatus, maxEvents, initialCursor) {
         let allEvents = [];
         let cursor = initialCursor || null;

package/dist/exchanges/kalshi/index.d.ts

@@ -1,5 +1,5 @@
-import { EventFetchParams, ExchangeCredentials, HistoryFilterParams, MarketFilterParams, MyTradesParams, OHLCVParams, OrderHistoryParams, PredictionMarketExchange, TradesParams } from '../../BaseExchange';
-import { Balance, BuiltOrder, CreateOrderParams, Order, OrderBook, Position, PriceCandle, Trade, UnifiedEvent, UnifiedMarket, UserTrade } from '../../types';
+import { EventFetchParams, ExchangeCredentials, HistoryFilterParams, MarketFilterParams, MyTradesParams, OHLCVParams, OrderHistoryParams, PredictionMarketExchange, SeriesFetchParams, TradesParams } from '../../BaseExchange';
+import { Balance, BuiltOrder, CreateOrderParams, Order, OrderBook, Position, PriceCandle, Trade, UnifiedEvent, UnifiedMarket, UnifiedSeries, UserTrade } from '../../types';
 import { KalshiWebSocketConfig } from './websocket';
 export type { KalshiWebSocketConfig };
 export interface KalshiExchangeOptions {
@@ -23,6 +23,7 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     private ensureAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    protected fetchSeriesImpl(params: SeriesFetchParams): Promise<UnifiedSeries[]>;
     fetchEventsPage(params?: EventFetchParams): Promise<{
         events: UnifiedEvent[];
         cursor: string | null;

package/dist/exchanges/kalshi/index.js

@@ -118,6 +118,39 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             .filter((e) => e !== null)
             .slice(0, limit);
     }
+    async fetchSeriesImpl(params) {
+        const rawList = await this.fetcher.fetchRawSeriesList();
+        // If a specific series id is requested, fetch its events and attach them.
+        // We still iterate the full list so filters apply uniformly.
+        let eventsById = null;
+        if (params.id) {
+            const rawEvents = await this.fetcher.fetchRawEvents({ series: params.id });
+            const normalizedEvents = rawEvents
+                .map((raw) => this.normalizer.normalizeEvent(raw))
+                .filter((e) => e !== null);
+            eventsById = new Map([[params.id, normalizedEvents]]);
+        }
+        const normalized = rawList.map((raw) => {
+            const events = eventsById?.get(raw.ticker);
+            return this.normalizer.normalizeSeries(raw, events);
+        });
+        // Client-side filters
+        let filtered = normalized;
+        if (params.id) {
+            filtered = filtered.filter((s) => s.id === params.id);
+        }
+        else if (params.slug) {
+            filtered = filtered.filter((s) => s.ticker === params.slug || s.slug === params.slug);
+        }
+        if (params.query) {
+            const lowerQuery = params.query.toLowerCase();
+            filtered = filtered.filter((s) => s.title.toLowerCase().includes(lowerQuery));
+        }
+        if (params.recurrence) {
+            filtered = filtered.filter((s) => s.recurrence === params.recurrence);
+        }
+        return filtered;
+    }
     async fetchEventsPage(params = {}) {
         const page = await this.fetcher.fetchRawEventPage(params);
         const query = (params?.query || '').toLowerCase();

package/dist/exchanges/kalshi/normalizer.d.ts

@@ -1,12 +1,13 @@
 import { OHLCVParams } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Position, Balance } from '../../types';
+import { UnifiedMarket, UnifiedEvent, UnifiedSeries, PriceCandle, OrderBook, Trade, UserTrade, Position, Balance } from '../../types';
 import { IExchangeNormalizer } from '../interfaces';
-import { KalshiRawEvent, KalshiRawMarket, KalshiRawCandlestick, KalshiRawTrade, KalshiRawFill, KalshiRawOrder, KalshiRawPosition, KalshiRawOrderBookFp } from './fetcher';
+import { KalshiRawEvent, KalshiRawMarket, KalshiRawCandlestick, KalshiRawTrade, KalshiRawFill, KalshiRawOrder, KalshiRawPosition, KalshiRawOrderBookFp, KalshiRawSeries } from './fetcher';
 export declare class KalshiNormalizer implements IExchangeNormalizer<KalshiRawEvent, KalshiRawEvent> {
     normalizeMarket(raw: KalshiRawEvent): UnifiedMarket | null;
     normalizeMarketsFromEvent(rawEvent: KalshiRawEvent): UnifiedMarket[];
     normalizeRawMarket(event: KalshiRawEvent, market: KalshiRawMarket): UnifiedMarket | null;
     normalizeEvent(raw: KalshiRawEvent): UnifiedEvent | null;
+    normalizeSeries(raw: KalshiRawSeries, events?: UnifiedEvent[]): UnifiedSeries;
     normalizeOHLCV(rawCandles: KalshiRawCandlestick[], params: OHLCVParams): PriceCandle[];
     normalizeOrderBook(raw: {
         orderbook_fp: KalshiRawOrderBookFp;

package/dist/exchanges/kalshi/normalizer.js

@@ -10,6 +10,9 @@ const price_1 = require("./price");
 const KALSHI_PROMOTED_EVENT_KEYS = [
     'event_ticker', 'title', 'markets', 'category', 'image_url', 'tags',
 ];
+const KALSHI_PROMOTED_SERIES_KEYS = [
+    'ticker', 'title', 'tags', 'frequency', 'category',
+];
 const KALSHI_PROMOTED_MARKET_KEYS = [
     'ticker', 'title', 'rules_primary', 'rules_secondary', 'expiration_time',
     'volume_24h_fp', 'volume_24h', 'volume', 'volume_fp',
@@ -137,6 +140,17 @@ class KalshiNormalizer {
             sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, KALSHI_PROMOTED_EVENT_KEYS),
         };
     }
+    normalizeSeries(raw, events) {
+        return {
+            id: raw.ticker,
+            ticker: raw.ticker,
+            title: (typeof raw.title === 'string' && raw.title.trim()) ? raw.title.trim() : raw.ticker,
+            recurrence: (typeof raw.frequency === 'string' && raw.frequency.trim()) ? raw.frequency.trim() : null,
+            url: `https://kalshi.com/events?series=${raw.ticker}`,
+            events: events ?? undefined,
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)(raw, KALSHI_PROMOTED_SERIES_KEYS),
+        };
+    }
     normalizeOHLCV(rawCandles, params) {
         const candles = rawCandles.map((c) => {
             const p = c.price || {};

package/dist/exchanges/limitless/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-05-30T12:19:28.209Z
+ * Generated at: 2026-05-30T13:35:15.569Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const limitlessApiSpec: {

package/dist/exchanges/limitless/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.limitlessApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-05-30T12:19:28.209Z
+ * Generated at: 2026-05-30T13:35:15.569Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.limitlessApiSpec = {

package/dist/exchanges/limitless/index.d.ts

@@ -13,6 +13,7 @@ export interface LimitlessExchangeOptions {
 export declare class LimitlessExchange extends PredictionMarketExchange {
     protected readonly capabilityOverrides: {
         fetchOrder: false;
+        fetchSeries: false;
     };
     private auth?;
     private client?;

package/dist/exchanges/limitless/index.js

@@ -22,6 +22,7 @@ const logger_1 = require("../../utils/logger");
 class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     capabilityOverrides = {
         fetchOrder: false,
+        fetchSeries: false,
     };
     auth;
     client;
@@ -146,6 +147,10 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         return marketsAfterOffset.slice(0, limit);
     }
     async fetchEventsImpl(params) {
+        // Venue does not expose a series concept; honoring `params.series` by
+        // returning [] rather than ignoring the filter.
+        if (params.series !== undefined)
+            return [];
         const rawEvents = await this.fetcher.fetchRawEvents(params);
         return rawEvents
             .map((raw) => this.normalizer.normalizeEvent(raw))

package/dist/exchanges/metaculus/fetchEvents.js

@@ -143,6 +143,10 @@ async function fetchEventBySlug(slug, callApi) {
     return [];
 }
 async function fetchEvents(params, callApi) {
+    // Venue does not expose a series concept; honoring `params.series` by returning [] rather than ignoring the filter.
+    if (params.series !== undefined) {
+        return [];
+    }
     try {
         // Direct lookup by slug (post ID, tournament slug, or url_title)
         if (params.slug) {