pmxtjs 2.35.29 → 2.35.32

package/dist/esm/generated/src/apis/DefaultApi.d.ts

@@ -10,7 +10,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime.js';
-import type { BaseResponse, BuildOrder200Response, BuildOrderRequest, CancelOrderRequest, CloseRequest, CompareMarketPrices200Response, CompareMarketPricesRequest, CreateOrder200Response, CreateOrderRequest, EventFilterCriteria, FetchArbitrage200Response, FetchBalance200Response, FetchEvent200Response, FetchEventMatches200Response, FetchEvents200Response, FetchEventsPaginated200Response, FetchMarket200Response, FetchMarketMatches200Response, FetchMarkets200Response, FetchMarketsPaginated200Response, FetchMatchedMarkets200Response, FetchMyTrades200Response, FetchOHLCV200Response, FetchOpenOrders200Response, FetchOrderBook200Response, FetchPositions200Response, FetchTrades200Response, FilterEventsRequest, FilterMarketsRequest, GetExecutionPrice200Response, GetExecutionPriceDetailed200Response, GetExecutionPriceDetailedRequest, GetExecutionPriceRequest, HealthCheck200Response, LoadMarkets200Response, LoadMarketsRequest, MarketFilterCriteria, SubmitOrderRequest, UnifiedEvent, UnifiedMarket, UnwatchAddressRequest, UnwatchOrderBookRequest, WatchAddress200Response, WatchAddressRequest, WatchOrderBookRequest, WatchTradesRequest } from '../models/index.js';
+import type { BaseResponse, BuildOrder200Response, BuildOrderRequest, CancelOrderRequest, CloseRequest, CompareMarketPrices200Response, CompareMarketPricesRequest, CreateOrder200Response, CreateOrderRequest, EventFilterCriteria, FetchArbitrage200Response, FetchBalance200Response, FetchEvent200Response, FetchEventMatches200Response, FetchEvents200Response, FetchEventsPaginated200Response, FetchMarket200Response, FetchMarketMatches200Response, FetchMarkets200Response, FetchMarketsPaginated200Response, FetchMatchedMarkets200Response, FetchMyTrades200Response, FetchOHLCV200Response, FetchOpenOrders200Response, FetchOrderBook200Response, FetchPositions200Response, FetchTrades200Response, FilterEventsRequest, FilterMarketsRequest, GetExecutionPrice200Response, GetExecutionPriceDetailed200Response, GetExecutionPriceDetailedRequest, GetExecutionPriceRequest, HealthCheck200Response, LoadMarkets200Response, LoadMarketsRequest, MarketFilterCriteria, SubmitOrderRequest, UnifiedEvent, UnifiedMarket, UnwatchAddressRequest, UnwatchOrderBookRequest, WatchAddress200Response, WatchAddressRequest, WatchOrderBookRequest, WatchOrderBooks200Response, WatchOrderBooksRequest, WatchTradesRequest } from '../models/index.js';
 export interface BuildOrderOperationRequest {
     exchange: BuildOrderOperationExchangeEnum;
     buildOrderRequest?: BuildOrderRequest;
@@ -279,6 +279,10 @@ export interface WatchOrderBookOperationRequest {
     exchange: WatchOrderBookOperationExchangeEnum;
     watchOrderBookRequest?: WatchOrderBookRequest;
 }
+export interface WatchOrderBooksOperationRequest {
+    exchange: WatchOrderBooksOperationExchangeEnum;
+    watchOrderBooksRequest?: WatchOrderBooksRequest;
+}
 export interface WatchTradesOperationRequest {
     exchange: WatchTradesOperationExchangeEnum;
     watchTradesRequest?: WatchTradesRequest;
@@ -669,6 +673,16 @@ export declare class DefaultApi extends runtime.BaseAPI {
      * Watch Order Book
      */
     watchOrderBook(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOrderBook200Response>;
+    /**
+     * Watch multiple order books simultaneously via WebSocket. Returns a promise that resolves with a record of order book snapshots keyed by ID. Exchanges with native batch support (e.g. Kalshi) send a single subscribe message for all tickers; others fall back to individual watchOrderBook calls.
+     * Watch Order Books
+     */
+    watchOrderBooksRaw(requestParameters: WatchOrderBooksOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchOrderBooks200Response>>;
+    /**
+     * Watch multiple order books simultaneously via WebSocket. Returns a promise that resolves with a record of order book snapshots keyed by ID. Exchanges with native batch support (e.g. Kalshi) send a single subscribe message for all tickers; others fall back to individual watchOrderBook calls.
+     * Watch Order Books
+     */
+    watchOrderBooks(requestParameters: WatchOrderBooksOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchOrderBooks200Response>;
     /**
      * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      * Watch Trades
@@ -1580,6 +1594,24 @@ export declare const WatchOrderBookOperationExchangeEnum: {
     readonly Router: "router";
 };
 export type WatchOrderBookOperationExchangeEnum = typeof WatchOrderBookOperationExchangeEnum[keyof typeof WatchOrderBookOperationExchangeEnum];
+/**
+ * @export
+ */
+export declare const WatchOrderBooksOperationExchangeEnum: {
+    readonly Polymarket: "polymarket";
+    readonly Kalshi: "kalshi";
+    readonly KalshiDemo: "kalshi-demo";
+    readonly Limitless: "limitless";
+    readonly Probable: "probable";
+    readonly Baozi: "baozi";
+    readonly Myriad: "myriad";
+    readonly Opinion: "opinion";
+    readonly Metaculus: "metaculus";
+    readonly Smarkets: "smarkets";
+    readonly PolymarketUs: "polymarket_us";
+    readonly Router: "router";
+};
+export type WatchOrderBooksOperationExchangeEnum = typeof WatchOrderBooksOperationExchangeEnum[keyof typeof WatchOrderBooksOperationExchangeEnum];
 /**
  * @export
  */

package/dist/esm/generated/src/apis/DefaultApi.js

@@ -12,7 +12,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime.js';
-import { BaseResponseFromJSON, BuildOrder200ResponseFromJSON, BuildOrderRequestToJSON, CancelOrderRequestToJSON, CloseRequestToJSON, CompareMarketPrices200ResponseFromJSON, CompareMarketPricesRequestToJSON, CreateOrder200ResponseFromJSON, CreateOrderRequestToJSON, FetchArbitrage200ResponseFromJSON, FetchBalance200ResponseFromJSON, FetchEvent200ResponseFromJSON, FetchEventMatches200ResponseFromJSON, FetchEvents200ResponseFromJSON, FetchEventsPaginated200ResponseFromJSON, FetchMarket200ResponseFromJSON, FetchMarketMatches200ResponseFromJSON, FetchMarkets200ResponseFromJSON, FetchMarketsPaginated200ResponseFromJSON, FetchMatchedMarkets200ResponseFromJSON, FetchMyTrades200ResponseFromJSON, FetchOHLCV200ResponseFromJSON, FetchOpenOrders200ResponseFromJSON, FetchOrderBook200ResponseFromJSON, FetchPositions200ResponseFromJSON, FetchTrades200ResponseFromJSON, FilterEventsRequestToJSON, FilterMarketsRequestToJSON, GetExecutionPrice200ResponseFromJSON, GetExecutionPriceDetailed200ResponseFromJSON, GetExecutionPriceDetailedRequestToJSON, GetExecutionPriceRequestToJSON, HealthCheck200ResponseFromJSON, LoadMarkets200ResponseFromJSON, LoadMarketsRequestToJSON, SubmitOrderRequestToJSON, UnwatchAddressRequestToJSON, UnwatchOrderBookRequestToJSON, WatchAddress200ResponseFromJSON, WatchAddressRequestToJSON, WatchOrderBookRequestToJSON, WatchTradesRequestToJSON, } from '../models/index.js';
+import { BaseResponseFromJSON, BuildOrder200ResponseFromJSON, BuildOrderRequestToJSON, CancelOrderRequestToJSON, CloseRequestToJSON, CompareMarketPrices200ResponseFromJSON, CompareMarketPricesRequestToJSON, CreateOrder200ResponseFromJSON, CreateOrderRequestToJSON, FetchArbitrage200ResponseFromJSON, FetchBalance200ResponseFromJSON, FetchEvent200ResponseFromJSON, FetchEventMatches200ResponseFromJSON, FetchEvents200ResponseFromJSON, FetchEventsPaginated200ResponseFromJSON, FetchMarket200ResponseFromJSON, FetchMarketMatches200ResponseFromJSON, FetchMarkets200ResponseFromJSON, FetchMarketsPaginated200ResponseFromJSON, FetchMatchedMarkets200ResponseFromJSON, FetchMyTrades200ResponseFromJSON, FetchOHLCV200ResponseFromJSON, FetchOpenOrders200ResponseFromJSON, FetchOrderBook200ResponseFromJSON, FetchPositions200ResponseFromJSON, FetchTrades200ResponseFromJSON, FilterEventsRequestToJSON, FilterMarketsRequestToJSON, GetExecutionPrice200ResponseFromJSON, GetExecutionPriceDetailed200ResponseFromJSON, GetExecutionPriceDetailedRequestToJSON, GetExecutionPriceRequestToJSON, HealthCheck200ResponseFromJSON, LoadMarkets200ResponseFromJSON, LoadMarketsRequestToJSON, SubmitOrderRequestToJSON, UnwatchAddressRequestToJSON, UnwatchOrderBookRequestToJSON, WatchAddress200ResponseFromJSON, WatchAddressRequestToJSON, WatchOrderBookRequestToJSON, WatchOrderBooks200ResponseFromJSON, WatchOrderBooksRequestToJSON, WatchTradesRequestToJSON, } from '../models/index.js';
 /**
  *
  */
@@ -1556,6 +1556,36 @@ export class DefaultApi extends runtime.BaseAPI {
         const response = await this.watchOrderBookRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Watch multiple order books simultaneously via WebSocket. Returns a promise that resolves with a record of order book snapshots keyed by ID. Exchanges with native batch support (e.g. Kalshi) send a single subscribe message for all tickers; others fall back to individual watchOrderBook calls.
+     * Watch Order Books
+     */
+    async watchOrderBooksRaw(requestParameters, initOverrides) {
+        if (requestParameters['exchange'] == null) {
+            throw new runtime.RequiredError('exchange', 'Required parameter "exchange" was null or undefined when calling watchOrderBooks().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        let urlPath = `/api/{exchange}/watchOrderBooks`;
+        urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: WatchOrderBooksRequestToJSON(requestParameters['watchOrderBooksRequest']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => WatchOrderBooks200ResponseFromJSON(jsonValue));
+    }
+    /**
+     * Watch multiple order books simultaneously via WebSocket. Returns a promise that resolves with a record of order book snapshots keyed by ID. Exchanges with native batch support (e.g. Kalshi) send a single subscribe message for all tickers; others fall back to individual watchOrderBook calls.
+     * Watch Order Books
+     */
+    async watchOrderBooks(requestParameters, initOverrides) {
+        const response = await this.watchOrderBooksRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      * Watch Trades
@@ -2427,6 +2457,23 @@ export const WatchOrderBookOperationExchangeEnum = {
     PolymarketUs: 'polymarket_us',
     Router: 'router'
 };
+/**
+ * @export
+ */
+export const WatchOrderBooksOperationExchangeEnum = {
+    Polymarket: 'polymarket',
+    Kalshi: 'kalshi',
+    KalshiDemo: 'kalshi-demo',
+    Limitless: 'limitless',
+    Probable: 'probable',
+    Baozi: 'baozi',
+    Myriad: 'myriad',
+    Opinion: 'opinion',
+    Metaculus: 'metaculus',
+    Smarkets: 'smarkets',
+    PolymarketUs: 'polymarket_us',
+    Router: 'router'
+};
 /**
  * @export
  */

package/dist/esm/generated/src/models/WatchOrderBooks200Response.d.ts

@@ -0,0 +1,48 @@
+/**
+ * PMXT Sidecar API
+ * A unified local sidecar API for prediction markets (Polymarket, Kalshi, Limitless). This API acts as a JSON-RPC-style gateway. Each endpoint corresponds to a specific method on the generic exchange implementation.
+ *
+ * The version of the OpenAPI document: 0.4.4
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ErrorDetail } from './ErrorDetail.js';
+import type { OrderBook } from './OrderBook.js';
+/**
+ *
+ * @export
+ * @interface WatchOrderBooks200Response
+ */
+export interface WatchOrderBooks200Response {
+    /**
+     *
+     * @type {boolean}
+     * @memberof WatchOrderBooks200Response
+     */
+    success?: boolean;
+    /**
+     *
+     * @type {ErrorDetail}
+     * @memberof WatchOrderBooks200Response
+     */
+    error?: ErrorDetail;
+    /**
+     *
+     * @type {{ [key: string]: OrderBook; }}
+     * @memberof WatchOrderBooks200Response
+     */
+    data?: {
+        [key: string]: OrderBook;
+    };
+}
+/**
+ * Check if a given object implements the WatchOrderBooks200Response interface.
+ */
+export declare function instanceOfWatchOrderBooks200Response(value: object): value is WatchOrderBooks200Response;
+export declare function WatchOrderBooks200ResponseFromJSON(json: any): WatchOrderBooks200Response;
+export declare function WatchOrderBooks200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): WatchOrderBooks200Response;
+export declare function WatchOrderBooks200ResponseToJSON(json: any): WatchOrderBooks200Response;
+export declare function WatchOrderBooks200ResponseToJSONTyped(value?: WatchOrderBooks200Response | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/generated/src/models/WatchOrderBooks200Response.js

@@ -0,0 +1,48 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * PMXT Sidecar API
+ * A unified local sidecar API for prediction markets (Polymarket, Kalshi, Limitless). This API acts as a JSON-RPC-style gateway. Each endpoint corresponds to a specific method on the generic exchange implementation.
+ *
+ * The version of the OpenAPI document: 0.4.4
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { mapValues } from '../runtime.js';
+import { ErrorDetailFromJSON, ErrorDetailToJSON, } from './ErrorDetail.js';
+import { OrderBookFromJSON, OrderBookToJSON, } from './OrderBook.js';
+/**
+ * Check if a given object implements the WatchOrderBooks200Response interface.
+ */
+export function instanceOfWatchOrderBooks200Response(value) {
+    return true;
+}
+export function WatchOrderBooks200ResponseFromJSON(json) {
+    return WatchOrderBooks200ResponseFromJSONTyped(json, false);
+}
+export function WatchOrderBooks200ResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'success': json['success'] == null ? undefined : json['success'],
+        'error': json['error'] == null ? undefined : ErrorDetailFromJSON(json['error']),
+        'data': json['data'] == null ? undefined : (mapValues(json['data'], OrderBookFromJSON)),
+    };
+}
+export function WatchOrderBooks200ResponseToJSON(json) {
+    return WatchOrderBooks200ResponseToJSONTyped(json, false);
+}
+export function WatchOrderBooks200ResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'success': value['success'],
+        'error': ErrorDetailToJSON(value['error']),
+        'data': value['data'] == null ? undefined : (mapValues(value['data'], OrderBookToJSON)),
+    };
+}

package/dist/esm/generated/src/models/WatchOrderBooksRequest.d.ts

@@ -0,0 +1,40 @@
+/**
+ * PMXT Sidecar API
+ * A unified local sidecar API for prediction markets (Polymarket, Kalshi, Limitless). This API acts as a JSON-RPC-style gateway. Each endpoint corresponds to a specific method on the generic exchange implementation.
+ *
+ * The version of the OpenAPI document: 0.4.4
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ExchangeCredentials } from './ExchangeCredentials.js';
+import type { WatchOrderBooksRequestArgsInner } from './WatchOrderBooksRequestArgsInner.js';
+/**
+ *
+ * @export
+ * @interface WatchOrderBooksRequest
+ */
+export interface WatchOrderBooksRequest {
+    /**
+     *
+     * @type {Array<WatchOrderBooksRequestArgsInner>}
+     * @memberof WatchOrderBooksRequest
+     */
+    args: Array<WatchOrderBooksRequestArgsInner>;
+    /**
+     *
+     * @type {ExchangeCredentials}
+     * @memberof WatchOrderBooksRequest
+     */
+    credentials?: ExchangeCredentials;
+}
+/**
+ * Check if a given object implements the WatchOrderBooksRequest interface.
+ */
+export declare function instanceOfWatchOrderBooksRequest(value: object): value is WatchOrderBooksRequest;
+export declare function WatchOrderBooksRequestFromJSON(json: any): WatchOrderBooksRequest;
+export declare function WatchOrderBooksRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): WatchOrderBooksRequest;
+export declare function WatchOrderBooksRequestToJSON(json: any): WatchOrderBooksRequest;
+export declare function WatchOrderBooksRequestToJSONTyped(value?: WatchOrderBooksRequest | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/generated/src/models/WatchOrderBooksRequest.js

@@ -0,0 +1,47 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * PMXT Sidecar API
+ * A unified local sidecar API for prediction markets (Polymarket, Kalshi, Limitless). This API acts as a JSON-RPC-style gateway. Each endpoint corresponds to a specific method on the generic exchange implementation.
+ *
+ * The version of the OpenAPI document: 0.4.4
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { ExchangeCredentialsFromJSON, ExchangeCredentialsToJSON, } from './ExchangeCredentials.js';
+import { WatchOrderBooksRequestArgsInnerFromJSON, WatchOrderBooksRequestArgsInnerToJSON, } from './WatchOrderBooksRequestArgsInner.js';
+/**
+ * Check if a given object implements the WatchOrderBooksRequest interface.
+ */
+export function instanceOfWatchOrderBooksRequest(value) {
+    if (!('args' in value) || value['args'] === undefined)
+        return false;
+    return true;
+}
+export function WatchOrderBooksRequestFromJSON(json) {
+    return WatchOrderBooksRequestFromJSONTyped(json, false);
+}
+export function WatchOrderBooksRequestFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'args': (json['args'].map(WatchOrderBooksRequestArgsInnerFromJSON)),
+        'credentials': json['credentials'] == null ? undefined : ExchangeCredentialsFromJSON(json['credentials']),
+    };
+}
+export function WatchOrderBooksRequestToJSON(json) {
+    return WatchOrderBooksRequestToJSONTyped(json, false);
+}
+export function WatchOrderBooksRequestToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'args': (value['args'].map(WatchOrderBooksRequestArgsInnerToJSON)),
+        'credentials': ExchangeCredentialsToJSON(value['credentials']),
+    };
+}

package/dist/esm/generated/src/models/WatchOrderBooksRequestArgsInner.d.ts

@@ -0,0 +1,21 @@
+/**
+ * PMXT Sidecar API
+ * A unified local sidecar API for prediction markets (Polymarket, Kalshi, Limitless). This API acts as a JSON-RPC-style gateway. Each endpoint corresponds to a specific method on the generic exchange implementation.
+ *
+ * The version of the OpenAPI document: 0.4.4
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * @type WatchOrderBooksRequestArgsInner
+ *
+ * @export
+ */
+export type WatchOrderBooksRequestArgsInner = Array<string> | number;
+export declare function WatchOrderBooksRequestArgsInnerFromJSON(json: any): WatchOrderBooksRequestArgsInner;
+export declare function WatchOrderBooksRequestArgsInnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): WatchOrderBooksRequestArgsInner;
+export declare function WatchOrderBooksRequestArgsInnerToJSON(json: any): any;
+export declare function WatchOrderBooksRequestArgsInnerToJSONTyped(value?: WatchOrderBooksRequestArgsInner | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/generated/src/models/WatchOrderBooksRequestArgsInner.js

@@ -0,0 +1,47 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * PMXT Sidecar API
+ * A unified local sidecar API for prediction markets (Polymarket, Kalshi, Limitless). This API acts as a JSON-RPC-style gateway. Each endpoint corresponds to a specific method on the generic exchange implementation.
+ *
+ * The version of the OpenAPI document: 0.4.4
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export function WatchOrderBooksRequestArgsInnerFromJSON(json) {
+    return WatchOrderBooksRequestArgsInnerFromJSONTyped(json, false);
+}
+export function WatchOrderBooksRequestArgsInnerFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    if (typeof json === 'number') {
+        return json;
+    }
+    if (Array.isArray(json)) {
+        if (json.every(item => typeof item === 'string')) {
+            return json;
+        }
+    }
+    return {};
+}
+export function WatchOrderBooksRequestArgsInnerToJSON(json) {
+    return WatchOrderBooksRequestArgsInnerToJSONTyped(json, false);
+}
+export function WatchOrderBooksRequestArgsInnerToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        if (value.every(item => typeof item === 'string')) {
+            return value;
+        }
+    }
+    return {};
+}

package/dist/esm/generated/src/models/index.d.ts

@@ -91,4 +91,7 @@ export * from './WatchAddressRequest.js';
 export * from './WatchAddressRequestArgsInner.js';
 export * from './WatchOrderBookRequest.js';
 export * from './WatchOrderBookRequestArgsInner.js';
+export * from './WatchOrderBooks200Response.js';
+export * from './WatchOrderBooksRequest.js';
+export * from './WatchOrderBooksRequestArgsInner.js';
 export * from './WatchTradesRequest.js';

package/dist/esm/generated/src/models/index.js

@@ -93,4 +93,7 @@ export * from './WatchAddressRequest.js';
 export * from './WatchAddressRequestArgsInner.js';
 export * from './WatchOrderBookRequest.js';
 export * from './WatchOrderBookRequestArgsInner.js';
+export * from './WatchOrderBooks200Response.js';
+export * from './WatchOrderBooksRequest.js';
+export * from './WatchOrderBooksRequestArgsInner.js';
 export * from './WatchTradesRequest.js';

package/dist/esm/pmxt/client.d.ts

@@ -75,6 +75,10 @@ export declare abstract class Exchange {
      * POST directly and skip the GET probe for the lifetime of this client.
      */
     private _getReadsUnsupported;
+    /** Shared WebSocket client for streaming methods (lazy). */
+    private _wsClient;
+    /** Sticky flag: true if the sidecar /ws endpoint is unavailable. */
+    private _wsUnsupported;
     constructor(exchangeName: string, options?: ExchangeOptions);
     private initializeServer;
     protected handleResponse(response: any): any;
@@ -96,6 +100,18 @@ export declare abstract class Exchange {
      * attempts to restart the sidecar.
      */
     private fetchWithRetry;
+    /**
+     * Return the shared WebSocket client, creating it on first use.
+     *
+     * Returns `null` if the sidecar /ws endpoint was previously found
+     * to be unavailable, letting callers fall back to HTTP.
+     */
+    private getOrCreateWs;
+    /**
+     * Attempt to use the WS transport for a watch method.
+     * Returns the raw data on success, or `null` if WS is unavailable.
+     */
+    private watchViaWs;
     /**
      * Call an exchange-specific REST endpoint by its operationId.
      * This provides direct access to all implicit API methods defined in
@@ -207,6 +223,32 @@ export declare abstract class Exchange {
      * ```
      */
     watchOrderBook(outcomeId: string | MarketOutcome, limit?: number): Promise<OrderBook>;
+    /**
+     * Watch real-time order book updates for multiple outcomes at once.
+     *
+     * Returns a record mapping each outcome ID (ticker) to its latest
+     * order book snapshot. Call repeatedly in a loop to stream updates
+     * (CCXT Pro pattern).
+     *
+     * Prefers the sidecar WebSocket transport when available, falling
+     * back to HTTP POST for older sidecars.
+     *
+     * @param outcomeIds - Array of outcome IDs (or MarketOutcome objects)
+     * @param limit - Optional depth limit for each order book
+     * @returns Record mapping ticker to OrderBook
+     *
+     * @example
+     * ```typescript
+     * const ids = markets.slice(0, 3).map(m => m.outcomes[0].outcomeId);
+     * while (true) {
+     *   const books = await exchange.watchOrderBooks(ids);
+     *   for (const [ticker, ob] of Object.entries(books)) {
+     *     console.log(`${ticker}: bid=${ob.bids[0]?.price}`);
+     *   }
+     * }
+     * ```
+     */
+    watchOrderBooks(outcomeIds: (string | MarketOutcome)[], limit?: number): Promise<Record<string, OrderBook>>;
     /**
      * Watch real-time trade updates via WebSocket.
      *

package/dist/esm/pmxt/client.js

@@ -9,6 +9,7 @@ import { MarketList, } from "./models.js";
 import { ServerManager } from "./server-manager.js";
 import { PmxtError, fromServerError } from "./errors.js";
 import { resolvePmxtBaseUrl } from "./constants.js";
+import { SidecarWsClient } from "./ws-client.js";
 /**
  * Resolve a MarketOutcome shorthand to a plain outcome ID string.
  * Accepts either a raw string ID or a MarketOutcome object.
@@ -245,6 +246,10 @@ export class Exchange {
      * POST directly and skip the GET probe for the lifetime of this client.
      */
     _getReadsUnsupported = false;
+    /** Shared WebSocket client for streaming methods (lazy). */
+    _wsClient = null;
+    /** Sticky flag: true if the sidecar /ws endpoint is unavailable. */
+    _wsUnsupported = false;
     constructor(exchangeName, options = {}) {
         this.exchangeName = exchangeName.toLowerCase();
         this.apiKey = options.apiKey;
@@ -380,6 +385,58 @@ export class Exchange {
         }
         throw lastError;
     }
+    /**
+     * Return the shared WebSocket client, creating it on first use.
+     *
+     * Returns `null` if the sidecar /ws endpoint was previously found
+     * to be unavailable, letting callers fall back to HTTP.
+     */
+    async getOrCreateWs() {
+        if (this._wsUnsupported)
+            return null;
+        if (this._wsClient?.connected)
+            return this._wsClient;
+        const host = this.resolveBaseUrl();
+        const accessToken = this.serverManager.getAccessToken();
+        const client = new SidecarWsClient(host, accessToken || undefined);
+        try {
+            // Trigger connection to validate the endpoint exists.
+            // subscribe() calls ensureConnected internally, but we want
+            // to detect failure eagerly so we can set _wsUnsupported.
+            await client.subscribe(this.exchangeName, "_ping", [], undefined, 3000).catch(() => {
+                // Expected -- no _ping method. The connection itself
+                // succeeded if we got a WS error frame back. If the
+                // connection itself failed, we'll catch below.
+            });
+            // If we got here without the connect promise rejecting,
+            // the WS endpoint exists.
+            if (!client.connected) {
+                throw new Error("WS handshake failed");
+            }
+        }
+        catch {
+            this._wsUnsupported = true;
+            client.close();
+            return null;
+        }
+        this._wsClient = client;
+        return this._wsClient;
+    }
+    /**
+     * Attempt to use the WS transport for a watch method.
+     * Returns the raw data on success, or `null` if WS is unavailable.
+     */
+    async watchViaWs(method, args) {
+        const ws = await this.getOrCreateWs();
+        if (!ws)
+            return null;
+        try {
+            return await ws.subscribe(this.exchangeName, method, args, this.getCredentials());
+        }
+        catch {
+            return null;
+        }
+    }
     // Low-Level API Access
     /**
      * Call an exchange-specific REST endpoint by its operationId.
@@ -1325,11 +1382,17 @@ export class Exchange {
     async watchOrderBook(outcomeId, limit) {
         await this.initPromise;
         const resolvedOutcomeId = resolveOutcomeId(outcomeId);
+        const args = [resolvedOutcomeId];
+        if (limit !== undefined) {
+            args.push(limit);
+        }
+        // Try WebSocket transport first
+        const wsData = await this.watchViaWs("watchOrderBook", args);
+        if (wsData !== null) {
+            return convertOrderBook(wsData);
+        }
+        // HTTP fallback
         try {
-            const args = [resolvedOutcomeId];
-            if (limit !== undefined) {
-                args.push(limit);
-            }
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchOrderBook`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -1352,6 +1415,88 @@ export class Exchange {
             throw new PmxtError(`Failed to watch order book: ${error}`);
         }
     }
+    /**
+     * Watch real-time order book updates for multiple outcomes at once.
+     *
+     * Returns a record mapping each outcome ID (ticker) to its latest
+     * order book snapshot. Call repeatedly in a loop to stream updates
+     * (CCXT Pro pattern).
+     *
+     * Prefers the sidecar WebSocket transport when available, falling
+     * back to HTTP POST for older sidecars.
+     *
+     * @param outcomeIds - Array of outcome IDs (or MarketOutcome objects)
+     * @param limit - Optional depth limit for each order book
+     * @returns Record mapping ticker to OrderBook
+     *
+     * @example
+     * ```typescript
+     * const ids = markets.slice(0, 3).map(m => m.outcomes[0].outcomeId);
+     * while (true) {
+     *   const books = await exchange.watchOrderBooks(ids);
+     *   for (const [ticker, ob] of Object.entries(books)) {
+     *     console.log(`${ticker}: bid=${ob.bids[0]?.price}`);
+     *   }
+     * }
+     * ```
+     */
+    async watchOrderBooks(outcomeIds, limit) {
+        await this.initPromise;
+        const resolvedIds = outcomeIds.map(resolveOutcomeId);
+        const args = [resolvedIds];
+        if (limit !== undefined) {
+            args.push(limit);
+        }
+        // Try WebSocket transport first
+        const ws = await this.getOrCreateWs();
+        if (ws) {
+            try {
+                const rawResult = await ws.subscribeBatch(this.exchangeName, "watchOrderBooks", args, this.getCredentials());
+                if (rawResult && typeof rawResult === "object") {
+                    const result = {};
+                    for (const [k, v] of Object.entries(rawResult)) {
+                        if (v && typeof v === "object") {
+                            result[k] = convertOrderBook(v);
+                        }
+                    }
+                    return result;
+                }
+            }
+            catch {
+                // fall through to HTTP
+            }
+        }
+        // HTTP fallback
+        try {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchOrderBooks`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const body = await response.json().catch(() => ({}));
+                if (body.error && typeof body.error === "object") {
+                    throw fromServerError(body.error);
+                }
+                throw new PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            if (data && typeof data === "object") {
+                const result = {};
+                for (const [k, v] of Object.entries(data)) {
+                    result[k] = convertOrderBook(v);
+                }
+                return result;
+            }
+            return {};
+        }
+        catch (error) {
+            if (error instanceof PmxtError)
+                throw error;
+            throw new PmxtError(`Failed to watch order books: ${error}`);
+        }
+    }
     /**
      * Watch real-time trade updates via WebSocket.
      *