pmxt-core 2.42.7 → 2.43.1

package/dist/BaseExchange.d.ts

@@ -202,6 +202,8 @@ export interface ExchangeHas {
     fetchOHLCV: ExchangeCapability;
     /** Whether this exchange supports fetching the order book. */
     fetchOrderBook: ExchangeCapability;
+    /** Whether this exchange supports fetching multiple market order books. */
+    fetchOrderBooks: ExchangeCapability;
     /** Whether this exchange supports fetching public trades. */
     fetchTrades: ExchangeCapability;
     /** Whether this exchange supports creating orders. */
@@ -459,17 +461,34 @@ export declare abstract class PredictionMarketExchange {
      */
     fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
     /**
-     * Fetch the current order book (bids/asks) for a specific outcome.
-     * Essential for calculating spread, depth, and execution prices.
+     * Fetch the order book (bids/asks) for a specific outcome.
      *
      * @param outcomeId - The Outcome ID (outcomeId) or market slug
-     * @param side - Optional 'yes' or 'no' to explicitly indicate the
-     *   outcome side. Required for exchanges where the API returns a
-     *   single orderbook per market (e.g. Limitless) and the caller
-     *   passes a slug instead of a token ID.
-     * @returns Current order book with bids and asks
-     */
-    fetchOrderBook(outcomeId: string, side?: 'yes' | 'no'): Promise<OrderBook>;
+     * @param limit - Max number of bid/ask levels to return (CCXT-style).
+     *   For range queries, limits the number of snapshots returned.
+     * @param params - Optional parameters:
+     *   - `side`: 'yes' or 'no' — explicitly indicate the outcome side
+     *     (required for exchanges like Limitless where the API returns a
+     *     single orderbook per market).
+     *   - `since`: Unix timestamp (ms) — fetch a historical snapshot from
+     *     the archive at or before this time (hosted API only).
+     *   - `until`: Unix timestamp (ms) — when combined with `since`,
+     *     returns an array of OrderBook snapshots between `since` and
+     *     `until` (hosted API only).
+     * @returns Order book with bids and asks. Returns OrderBook[] when
+     *   both `since` and `until` are provided.
+     */
+    fetchOrderBook(outcomeId: string, limit?: number, params?: Record<string, any>): Promise<OrderBook>;
+    /**
+     * Batch variant of {@link fetchOrderBook}. Fetches order books for
+     * multiple outcomes in a single request where the exchange supports it.
+     *
+     * @param outcomeIds - List of Outcome IDs (outcomeId). Each id must be in the
+     *   exchange's native format; market slugs are not accepted here.
+     * @returns A map keyed by the input id (preserving the caller's exact
+     *   string) to its order book. Throws `NotFound` if any id has no book.
+     */
+    fetchOrderBooks(outcomeIds: string[]): Promise<Record<string, OrderBook>>;
     /**
      * Fetch raw trade history for a specific outcome.
      *
@@ -584,9 +603,10 @@ export declare abstract class PredictionMarketExchange {
      *
      * @param outcomeId - The Outcome ID to watch
      * @param limit - Optional limit for orderbook depth
+     * @param params - Optional exchange-specific parameters
      * @returns Promise that resolves with the current orderbook state
      */
-    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
+    watchOrderBook(outcomeId: string, limit?: number, params?: Record<string, any>): Promise<OrderBook>;
     /**
      * Watch multiple order books simultaneously via WebSocket.
      * Returns a promise that resolves with a record of order book snapshots keyed by ID.
@@ -595,9 +615,10 @@ export declare abstract class PredictionMarketExchange {
      *
      * @param outcomeIds - Array of Outcome IDs to watch
      * @param limit - Optional limit for orderbook depth
+     * @param params - Optional exchange-specific parameters
      * @returns Promise that resolves with order books keyed by ID
      */
-    watchOrderBooks(outcomeIds: string[], limit?: number): Promise<Record<string, OrderBook>>;
+    watchOrderBooks(outcomeIds: string[], limit?: number, params?: Record<string, any>): Promise<Record<string, OrderBook>>;
     /**
      * Unsubscribe from a previously watched order book stream.
      *
@@ -728,7 +749,7 @@ export declare abstract class PredictionMarketExchange {
      * Provides a typed entry point so unified methods can delegate to the implicit API
      * without casting to `any` everywhere.
      */
-    protected callApi(operationId: string, params?: Record<string, any>): Promise<any>;
+    protected callApi(operationId: string, params?: Record<string, any> | any[]): Promise<any>;
     /**
      * Parse an API descriptor and generate callable methods on this instance.
      * Existing methods (unified API) are never overwritten.

package/dist/BaseExchange.js

@@ -54,7 +54,21 @@ class PredictionMarketExchange {
         this.http = axios_1.default.create({
             headers: {
                 'User-Agent': `pmxt (https://github.com/pmxt-dev/pmxt)`
-            }
+            },
+            paramsSerializer: {
+                serialize: (params) => {
+                    const sp = new URLSearchParams();
+                    for (const [k, v] of Object.entries(params)) {
+                        if (v === undefined || v === null)
+                            continue;
+                        if (Array.isArray(v))
+                            v.forEach((x) => sp.append(k, String(x)));
+                        else
+                            sp.append(k, String(v));
+                    }
+                    return sp.toString();
+                },
+            },
         });
         this._throttler = new throttler_1.Throttler({
             refillRate: 1 / this._rateLimit,
@@ -403,19 +417,38 @@ class PredictionMarketExchange {
         throw new Error("Method fetchOHLCV not implemented.");
     }
     /**
-     * Fetch the current order book (bids/asks) for a specific outcome.
-     * Essential for calculating spread, depth, and execution prices.
+     * Fetch the order book (bids/asks) for a specific outcome.
      *
      * @param outcomeId - The Outcome ID (outcomeId) or market slug
-     * @param side - Optional 'yes' or 'no' to explicitly indicate the
-     *   outcome side. Required for exchanges where the API returns a
-     *   single orderbook per market (e.g. Limitless) and the caller
-     *   passes a slug instead of a token ID.
-     * @returns Current order book with bids and asks
+     * @param limit - Max number of bid/ask levels to return (CCXT-style).
+     *   For range queries, limits the number of snapshots returned.
+     * @param params - Optional parameters:
+     *   - `side`: 'yes' or 'no' — explicitly indicate the outcome side
+     *     (required for exchanges like Limitless where the API returns a
+     *     single orderbook per market).
+     *   - `since`: Unix timestamp (ms) — fetch a historical snapshot from
+     *     the archive at or before this time (hosted API only).
+     *   - `until`: Unix timestamp (ms) — when combined with `since`,
+     *     returns an array of OrderBook snapshots between `since` and
+     *     `until` (hosted API only).
+     * @returns Order book with bids and asks. Returns OrderBook[] when
+     *   both `since` and `until` are provided.
      */
-    async fetchOrderBook(outcomeId, side) {
+    async fetchOrderBook(outcomeId, limit, params) {
         throw new Error("Method fetchOrderBook not implemented.");
     }
+    /**
+     * Batch variant of {@link fetchOrderBook}. Fetches order books for
+     * multiple outcomes in a single request where the exchange supports it.
+     *
+     * @param outcomeIds - List of Outcome IDs (outcomeId). Each id must be in the
+     *   exchange's native format; market slugs are not accepted here.
+     * @returns A map keyed by the input id (preserving the caller's exact
+     *   string) to its order book. Throws `NotFound` if any id has no book.
+     */
+    async fetchOrderBooks(outcomeIds) {
+        throw new Error("Method fetchOrderBooks not implemented.");
+    }
     /**
      * Fetch raw trade history for a specific outcome.
      *
@@ -763,9 +796,10 @@ class PredictionMarketExchange {
      *
      * @param outcomeId - The Outcome ID to watch
      * @param limit - Optional limit for orderbook depth
+     * @param params - Optional exchange-specific parameters
      * @returns Promise that resolves with the current orderbook state
      */
-    async watchOrderBook(outcomeId, limit) {
+    async watchOrderBook(outcomeId, limit, params = {}) {
         throw new Error(`watchOrderBook() is not supported by ${this.name}`);
     }
     /**
@@ -776,14 +810,15 @@ class PredictionMarketExchange {
      *
      * @param outcomeIds - Array of Outcome IDs to watch
      * @param limit - Optional limit for orderbook depth
+     * @param params - Optional exchange-specific parameters
      * @returns Promise that resolves with order books keyed by ID
      */
-    async watchOrderBooks(outcomeIds, limit) {
+    async watchOrderBooks(outcomeIds, limit, params = {}) {
         // Default implementation: subscribe to each ID individually.
         // Exchanges with native batch support (e.g. Kalshi) override this
         // to send a single subscribe message for all tickers.
         const entries = await Promise.all(outcomeIds.map(async (oid) => {
-            const book = await this.watchOrderBook(oid, limit);
+            const book = await this.watchOrderBook(oid, limit, params);
             return [oid, book];
         }));
         const result = {};
@@ -1014,7 +1049,8 @@ class PredictionMarketExchange {
      */
     createImplicitMethod(name, endpoint, resolvedBaseUrl) {
         return async (params) => {
-            const allParams = { ...(params || {}) };
+            const isArray = Array.isArray(params);
+            const allParams = isArray ? {} : { ...(params || {}) };
             // Substitute path parameters like {ticker} from params
             let resolvedPath = endpoint.path.replace(/\{([^}]+)\}/g, (_match, key) => {
                 const value = allParams[key];
@@ -1044,11 +1080,15 @@ class PredictionMarketExchange {
                     });
                 }
                 else {
-                    // POST/PUT/PATCH: remaining params go to JSON body
+                    // POST/PUT/PATCH: array payloads go through as-is; object
+                    // payloads send remaining params.
+                    const body = isArray
+                        ? params
+                        : (Object.keys(allParams).length > 0 ? allParams : undefined);
                     response = await this.http.request({
                         method: method,
                         url,
-                        data: Object.keys(allParams).length > 0 ? allParams : undefined,
+                        data: body,
                         headers: { 'Content-Type': 'application/json', ...headers },
                     });
                 }
@@ -1064,7 +1104,7 @@ class PredictionMarketExchange {
     // ----------------------------------------------------------------------------
     /** All keys that appear in ExchangeHas -- kept in sync via the exhaustive check below. */
     static _capabilityKeys = [
-        'fetchMarkets', 'fetchEvents', 'fetchOHLCV', 'fetchOrderBook',
+        'fetchMarkets', 'fetchEvents', 'fetchOHLCV', 'fetchOrderBook', 'fetchOrderBooks',
         'fetchTrades', 'createOrder', 'cancelOrder', 'fetchOrder',
         'fetchOpenOrders', 'fetchPositions', 'fetchBalance',
         'watchAddress', 'unwatchAddress', 'watchOrderBook', 'watchOrderBooks',
@@ -1077,7 +1117,7 @@ class PredictionMarketExchange {
     // ExchangeHas but is missing from _capabilityKeys above.
     static _exhaustiveCheck = {
         fetchMarkets: true, fetchEvents: true, fetchOHLCV: true,
-        fetchOrderBook: true, fetchTrades: true, createOrder: true,
+        fetchOrderBook: true, fetchOrderBooks: true, fetchTrades: true, createOrder: true,
         cancelOrder: true, fetchOrder: true, fetchOpenOrders: true,
         fetchPositions: true, fetchBalance: true, watchAddress: true,
         unwatchAddress: true, watchOrderBook: true, watchOrderBooks: true, unwatchOrderBook: true,

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

@@ -23,7 +23,7 @@ export declare class BaoziExchange extends PredictionMarketExchange {
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOHLCV(): Promise<PriceCandle[]>;
-    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
     fetchTrades(): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
     fetchPositions(): Promise<Position[]>;
@@ -31,7 +31,7 @@ export declare class BaoziExchange extends PredictionMarketExchange {
     cancelOrder(): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(): Promise<Order[]>;
-    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
     watchTrades(): Promise<Trade[]>;
     close(): Promise<void>;
     private ensureAuth;

package/dist/exchanges/baozi/index.js

@@ -71,7 +71,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         // Baozi has no historical price/trade API without a custom indexer
         return [];
     }
-    async fetchOrderBook(outcomeId) {
+    async fetchOrderBook(outcomeId, _limit, _params) {
         const rawMarket = await this.fetcher.fetchRawOrderBook(outcomeId);
         return this.normalizer.normalizeOrderBook(rawMarket, outcomeId);
     }
@@ -315,7 +315,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
     // -----------------------------------------------------------------------
     // WebSocket
     // -----------------------------------------------------------------------
-    async watchOrderBook(outcomeId) {
+    async watchOrderBook(outcomeId, _limit, _params = {}) {
         if (!this.ws) {
             this.ws = new websocket_1.BaoziWebSocket();
         }

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

@@ -15,7 +15,7 @@ export declare class GeminiTitanExchange extends PredictionMarketExchange {
     private requireAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
     buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
     submitOrder(built: BuiltOrder): Promise<Order>;
     createOrder(params: CreateOrderParams): Promise<Order>;
@@ -25,7 +25,7 @@ export declare class GeminiTitanExchange extends PredictionMarketExchange {
     fetchAllOrders(): Promise<Order[]>;
     fetchPositions(): Promise<Position[]>;
     private ensureWebSocket;
-    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
     watchTrades(outcomeId: string): Promise<Trade[]>;
     close(): Promise<void>;
 }

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

@@ -67,7 +67,7 @@ class GeminiTitanExchange extends BaseExchange_1.PredictionMarketExchange {
             .map(e => this.normalizer.normalizeEventWithMarkets(e))
             .filter((e) => e !== null);
     }
-    async fetchOrderBook(outcomeId) {
+    async fetchOrderBook(outcomeId, _limit, _params) {
         const { instrumentSymbol } = (0, utils_1.fromOutcomeId)(outcomeId);
         const raw = await this.fetcher.fetchRawOrderBook(instrumentSymbol);
         if (!raw) {
@@ -170,7 +170,7 @@ class GeminiTitanExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return this.geminiWs;
     }
-    async watchOrderBook(outcomeId) {
+    async watchOrderBook(outcomeId, _limit, _params = {}) {
         const { instrumentSymbol } = (0, utils_1.fromOutcomeId)(outcomeId);
         return this.ensureWebSocket().watchOrderBook(instrumentSymbol);
     }

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

@@ -16,7 +16,7 @@ export declare class HyperliquidExchange extends PredictionMarketExchange {
     private requireAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
     fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
     fetchTrades(outcomeId: string, params?: TradesParams): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;

package/dist/exchanges/hyperliquid/index.js

@@ -78,7 +78,7 @@ class HyperliquidExchange extends BaseExchange_1.PredictionMarketExchange {
             .map(q => this.normalizer.normalizeEventWithMarkets(q, meta, mids))
             .filter((e) => e !== null);
     }
-    async fetchOrderBook(outcomeId) {
+    async fetchOrderBook(outcomeId, _limit, _params) {
         const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
         return this.normalizer.normalizeOrderBook(raw, outcomeId);
     }

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-22T13:35:19.499Z
+ * Generated at: 2026-05-22T19:26:54.077Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {
@@ -1252,6 +1252,37 @@ export declare const kalshiApiSpec: {
                 })[];
             };
         };
+        "/markets/orderbooks": {
+            get: {
+                operationId: string;
+                summary: string;
+                tags: string[];
+                security: {
+                    kalshiAccessKey: never[];
+                    kalshiAccessSignature: never[];
+                    kalshiAccessTimestamp: never[];
+                }[];
+                parameters: {
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                        items: {
+                            type: string;
+                            maxLength: number;
+                        };
+                        minItems: number;
+                        maxItems: number;
+                    };
+                    style: string;
+                    explode: boolean;
+                    "x-oapi-codegen-extra-tags": {
+                        validate: string;
+                    };
+                }[];
+            };
+        };
         "/milestones/{milestone_id}": {
             get: {
                 operationId: string;

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-22T13:35:19.499Z
+ * Generated at: 2026-05-22T19:26:54.077Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {
@@ -1738,6 +1738,43 @@ exports.kalshiApiSpec = {
                 ]
             }
         },
+        "/markets/orderbooks": {
+            "get": {
+                "operationId": "GetMarketOrderbooks",
+                "summary": "Get Multiple Market Orderbooks",
+                "tags": [
+                    "market"
+                ],
+                "security": [
+                    {
+                        "kalshiAccessKey": [],
+                        "kalshiAccessSignature": [],
+                        "kalshiAccessTimestamp": []
+                    }
+                ],
+                "parameters": [
+                    {
+                        "name": "tickers",
+                        "in": "query",
+                        "required": true,
+                        "schema": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "maxLength": 200
+                            },
+                            "minItems": 1,
+                            "maxItems": 100
+                        },
+                        "style": "form",
+                        "explode": true,
+                        "x-oapi-codegen-extra-tags": {
+                            "validate": "required,min=1,max=100,dive,max=200"
+                        }
+                    }
+                ]
+            }
+        },
         "/milestones/{milestone_id}": {
             "get": {
                 "operationId": "GetMilestone",

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

@@ -1,5 +1,5 @@
-import { MarketFilterParams, EventFetchParams, OHLCVParams, TradesParams, MyTradesParams } from '../../BaseExchange';
-import { IExchangeFetcher, FetcherContext } from '../interfaces';
+import { EventFetchParams, MarketFilterParams, MyTradesParams, OHLCVParams, TradesParams } from '../../BaseExchange';
+import { FetcherContext, IExchangeFetcher } from '../interfaces';
 export interface KalshiRawMarket {
     ticker: string;
     last_price?: number;
@@ -63,6 +63,13 @@ export interface KalshiRawOrderBookFp {
     yes_dollars?: string[][];
     no_dollars?: string[][];
 }
+export interface KalshiRawOrderBook {
+    ticker: string;
+    orderbook_fp: KalshiRawOrderBookFp;
+}
+export interface KalshiRawOrderBooks {
+    orderbooks: KalshiRawOrderBook[];
+}
 export interface KalshiRawTrade {
     trade_id: string;
     created_time: string;
@@ -121,9 +128,8 @@ export declare class KalshiFetcher implements IExchangeFetcher<KalshiRawEvent, K
     fetchRawMarkets(params?: MarketFilterParams): Promise<KalshiRawEvent[]>;
     fetchRawEvents(params: EventFetchParams): Promise<KalshiRawEvent[]>;
     fetchRawOHLCV(id: string, params: OHLCVParams): Promise<KalshiRawCandlestick[]>;
-    fetchRawOrderBook(id: string): Promise<{
-        orderbook_fp: KalshiRawOrderBookFp;
-    }>;
+    fetchRawOrderBook(id: string): Promise<KalshiRawOrderBook>;
+    fetchRawOrderBooks(ids: string[]): Promise<KalshiRawOrderBook[]>;
     fetchRawTrades(id: string, params: TradesParams): Promise<KalshiRawTrade[]>;
     fetchRawMyTrades(params: MyTradesParams): Promise<KalshiRawFill[]>;
     fetchRawPositions(): Promise<KalshiRawPosition[]>;

package/dist/exchanges/kalshi/fetcher.js

@@ -139,6 +139,18 @@ class KalshiFetcher {
         }
         return data;
     }
+    async fetchRawOrderBooks(ids) {
+        ids.forEach((id) => (0, validation_1.validateIdFormat)(id, 'OrderBook'));
+        const tickers = [...new Set(ids.map(id => id.replace(/-NO$/, '')))];
+        const data = await this.ctx.callApi('GetMarketOrderbooks', { tickers });
+        const orderBooks = data.orderbooks;
+        if (tickers.length !== orderBooks.length) {
+            const returned = new Set(orderBooks.map(item => item.ticker));
+            const missing = tickers.filter(t => !returned.has(t));
+            throw new errors_2.NotFound(`Order book not found for tickers ${missing.join(', ')}`, 'Kalshi');
+        }
+        return orderBooks;
+    }
     // -- Trades ----------------------------------------------------------------
     async fetchRawTrades(id, params) {
         const ticker = id.replace(/-NO$/, '');

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

@@ -1,6 +1,6 @@
-import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams, MyTradesParams, OrderHistoryParams } from "../../BaseExchange";
-import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Balance, Order, Position, CreateOrderParams, BuiltOrder } from "../../types";
-import { KalshiWebSocketConfig } from "./websocket";
+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 { KalshiWebSocketConfig } from './websocket';
 export type { KalshiWebSocketConfig };
 export interface KalshiExchangeOptions {
     credentials?: ExchangeCredentials;
@@ -24,7 +24,8 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
-    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string, _limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
+    fetchOrderBooks(outcomeIds: string[]): Promise<Record<string, OrderBook>>;
     fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
@@ -38,8 +39,8 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     private ws?;
-    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
-    watchOrderBooks(outcomeIds: string[], limit?: number): Promise<Record<string, OrderBook>>;
+    watchOrderBook(outcomeId: string, limit?: number, _params?: Record<string, any>): Promise<OrderBook>;
+    watchOrderBooks(outcomeIds: string[], limit?: number, _params?: Record<string, any>): Promise<Record<string, OrderBook>>;
     watchTrades(outcomeId: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
     close(): Promise<void>;
 }