pmxtjs 2.35.30 → 2.35.32

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

@@ -0,0 +1,37 @@
+/**
+ * WebSocket client for streaming methods.
+ *
+ * Provides a multiplexed WebSocket connection to the sidecar server,
+ * used by watchOrderBook and watchOrderBooks as an alternative to
+ * HTTP long-polling. Falls back to HTTP transparently when the sidecar
+ * does not support the /ws endpoint.
+ */
+/**
+ * Multiplexed WebSocket client for the pmxt sidecar.
+ *
+ * Lazily connects to ws://{host}/ws?token={accessToken}. A single
+ * WebSocket connection is shared across all streaming subscriptions.
+ */
+export declare class SidecarWsClient {
+    private ws;
+    private host;
+    private accessToken;
+    private closed;
+    /** requestId -> latest data payload */
+    private dataStore;
+    /** requestId -> subscription metadata */
+    private subscriptions;
+    /** (method:symbolKey) -> requestId -- avoids duplicate subscribes */
+    private activeSubs;
+    private connectPromise;
+    constructor(host: string, accessToken?: string);
+    private ensureConnected;
+    private connect;
+    private getWebSocketConstructor;
+    private dispatch;
+    subscribe(exchange: string, method: string, args: any[], credentials?: Record<string, any>, timeoutMs?: number): Promise<any>;
+    subscribeBatch(exchange: string, method: string, args: any[], credentials?: Record<string, any>, timeoutMs?: number): Promise<Record<string, any>>;
+    close(): void;
+    get connected(): boolean;
+    private waitForData;
+}

package/dist/esm/pmxt/ws-client.js

@@ -0,0 +1,272 @@
+/**
+ * WebSocket client for streaming methods.
+ *
+ * Provides a multiplexed WebSocket connection to the sidecar server,
+ * used by watchOrderBook and watchOrderBooks as an alternative to
+ * HTTP long-polling. Falls back to HTTP transparently when the sidecar
+ * does not support the /ws endpoint.
+ */
+import { PmxtError } from "./errors.js";
+/**
+ * Multiplexed WebSocket client for the pmxt sidecar.
+ *
+ * Lazily connects to ws://{host}/ws?token={accessToken}. A single
+ * WebSocket connection is shared across all streaming subscriptions.
+ */
+export class SidecarWsClient {
+    ws = null;
+    host;
+    accessToken;
+    closed = false;
+    /** requestId -> latest data payload */
+    dataStore = new Map();
+    /** requestId -> subscription metadata */
+    subscriptions = new Map();
+    /** (method:symbolKey) -> requestId -- avoids duplicate subscribes */
+    activeSubs = new Map();
+    connectPromise = null;
+    constructor(host, accessToken) {
+        this.host = host;
+        this.accessToken = accessToken;
+    }
+    // ------------------------------------------------------------------
+    // Connection lifecycle
+    // ------------------------------------------------------------------
+    async ensureConnected() {
+        if (this.ws && !this.closed)
+            return;
+        if (this.connectPromise)
+            return this.connectPromise;
+        this.connectPromise = this.connect();
+        try {
+            await this.connectPromise;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            let hostPart = this.host;
+            let scheme = "ws";
+            if (hostPart.startsWith("https://")) {
+                hostPart = hostPart.slice("https://".length);
+                scheme = "wss";
+            }
+            else if (hostPart.startsWith("http://")) {
+                hostPart = hostPart.slice("http://".length);
+            }
+            let url = `${scheme}://${hostPart}/ws`;
+            if (this.accessToken) {
+                url = `${url}?token=${this.accessToken}`;
+            }
+            // Use the ws package in Node.js, native WebSocket in browsers
+            const WsConstructor = this.getWebSocketConstructor();
+            if (!WsConstructor) {
+                reject(new PmxtError("No WebSocket implementation available"));
+                return;
+            }
+            const ws = new WsConstructor(url);
+            this.closed = false;
+            ws.onopen = () => {
+                this.ws = ws;
+                resolve();
+            };
+            ws.onerror = (err) => {
+                if (!this.ws) {
+                    // Connection failed during handshake
+                    reject(new PmxtError(`WebSocket connection failed: ${err.message || err}`));
+                }
+            };
+            ws.onclose = () => {
+                this.closed = true;
+                this.ws = null;
+            };
+            ws.onmessage = (event) => {
+                try {
+                    const data = typeof event.data === "string"
+                        ? event.data
+                        : event.data.toString();
+                    const msg = JSON.parse(data);
+                    this.dispatch(msg);
+                }
+                catch {
+                    // Ignore unparseable frames
+                }
+            };
+        });
+    }
+    getWebSocketConstructor() {
+        // Browser / Deno / Bun
+        if (typeof globalThis !== "undefined" && globalThis.WebSocket) {
+            return globalThis.WebSocket;
+        }
+        // Node.js -- try to require ws
+        try {
+            // Dynamic require to avoid bundler issues
+            const wsModule = require("ws");
+            return wsModule.default || wsModule;
+        }
+        catch {
+            return null;
+        }
+    }
+    dispatch(msg) {
+        const eventType = msg.event;
+        const requestId = msg.id;
+        if (eventType === "error" && requestId) {
+            const sub = this.subscriptions.get(requestId);
+            if (sub?.reject) {
+                sub.reject(new PmxtError(msg.error?.message || "WebSocket subscription error"));
+                sub.reject = null;
+                sub.resolve = null;
+            }
+            return;
+        }
+        if (eventType === "subscribed") {
+            // Acknowledgement -- nothing to do
+            return;
+        }
+        if (eventType === "data" && requestId) {
+            const symbol = msg.symbol || "";
+            const data = msg.data || {};
+            // Store by (requestId:symbol) for batch methods
+            this.dataStore.set(`${requestId}:${symbol}`, data);
+            // Store by requestId alone for single-symbol methods
+            this.dataStore.set(requestId, data);
+            const sub = this.subscriptions.get(requestId);
+            if (sub?.resolve) {
+                sub.resolve(data);
+                sub.resolve = null;
+                sub.reject = null;
+            }
+        }
+    }
+    // ------------------------------------------------------------------
+    // Public API
+    // ------------------------------------------------------------------
+    async subscribe(exchange, method, args, credentials, timeoutMs = 30000) {
+        const firstArg = args[0] ?? "";
+        const subKey = Array.isArray(firstArg)
+            ? `${method}:${[...firstArg].sort().join(",")}`
+            : `${method}:${firstArg}`;
+        // Reuse existing subscription
+        const existingId = this.activeSubs.get(subKey);
+        if (existingId && this.subscriptions.has(existingId)) {
+            return this.waitForData(existingId, timeoutMs);
+        }
+        await this.ensureConnected();
+        const requestId = `req-${Math.random().toString(36).slice(2, 14)}`;
+        const symbols = Array.isArray(firstArg) ? firstArg : firstArg ? [firstArg] : [];
+        const sub = {
+            requestId,
+            method,
+            symbols,
+            resolve: null,
+            reject: null,
+        };
+        this.subscriptions.set(requestId, sub);
+        this.activeSubs.set(subKey, requestId);
+        const message = {
+            id: requestId,
+            action: "subscribe",
+            exchange,
+            method,
+            args,
+        };
+        if (credentials) {
+            message.credentials = credentials;
+        }
+        this.ws.send(JSON.stringify(message));
+        return this.waitForData(requestId, timeoutMs);
+    }
+    async subscribeBatch(exchange, method, args, credentials, timeoutMs = 30000) {
+        const symbols = Array.isArray(args[0]) ? args[0] : [];
+        await this.ensureConnected();
+        const requestId = `req-${Math.random().toString(36).slice(2, 14)}`;
+        const sub = {
+            requestId,
+            method,
+            symbols,
+            resolve: null,
+            reject: null,
+        };
+        this.subscriptions.set(requestId, sub);
+        const message = {
+            id: requestId,
+            action: "subscribe",
+            exchange,
+            method,
+            args,
+        };
+        if (credentials) {
+            message.credentials = credentials;
+        }
+        this.ws.send(JSON.stringify(message));
+        // Wait for first data event
+        await this.waitForData(requestId, timeoutMs);
+        // Collect per-symbol data
+        const result = {};
+        for (const symbol of symbols) {
+            const storeKey = `${requestId}:${symbol}`;
+            const data = this.dataStore.get(storeKey);
+            if (data !== undefined) {
+                result[symbol] = data;
+            }
+        }
+        // If no per-symbol data, return the single data event as-is
+        if (Object.keys(result).length === 0) {
+            const data = this.dataStore.get(requestId);
+            if (data && typeof data === "object") {
+                return data;
+            }
+        }
+        return result;
+    }
+    close() {
+        this.closed = true;
+        if (this.ws) {
+            try {
+                this.ws.close();
+            }
+            catch {
+                // ignore
+            }
+            this.ws = null;
+        }
+    }
+    get connected() {
+        return this.ws !== null && !this.closed;
+    }
+    // ------------------------------------------------------------------
+    // Internal
+    // ------------------------------------------------------------------
+    waitForData(requestId, timeoutMs) {
+        // Check if data is already available
+        const existing = this.dataStore.get(requestId);
+        if (existing !== undefined) {
+            this.dataStore.delete(requestId);
+            return Promise.resolve(existing);
+        }
+        return new Promise((resolve, reject) => {
+            const sub = this.subscriptions.get(requestId);
+            if (!sub) {
+                reject(new PmxtError("Subscription not found"));
+                return;
+            }
+            const timer = setTimeout(() => {
+                sub.resolve = null;
+                sub.reject = null;
+                reject(new PmxtError(`Timeout waiting for WebSocket data (method=${sub.method})`));
+            }, timeoutMs);
+            sub.resolve = (data) => {
+                clearTimeout(timer);
+                resolve(data);
+            };
+            sub.reject = (err) => {
+                clearTimeout(timer);
+                reject(err);
+            };
+        });
+    }
+}

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

@@ -10,7 +10,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-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';
+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';
 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/generated/src/apis/DefaultApi.js

@@ -47,7 +47,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FetchRelatedMarketsSortEnum = exports.FetchRelatedMarketsRelationEnum = exports.FetchRelatedMarketsExchangeEnum = exports.FetchPositionsExchangeEnum = exports.FetchOrderBookExchangeEnum = exports.FetchOrderExchangeEnum = exports.FetchOpenOrdersExchangeEnum = exports.FetchOHLCVExchangeEnum = exports.FetchMyTradesExchangeEnum = exports.FetchMatchedPricesRelationsEnum = exports.FetchMatchedPricesExchangeEnum = exports.FetchMatchedMarketsRelationsEnum = exports.FetchMatchedMarketsExchangeEnum = exports.FetchMarketsPaginatedExchangeEnum = exports.FetchMarketsSearchInEnum = exports.FetchMarketsStatusEnum = exports.FetchMarketsSortEnum = exports.FetchMarketsExchangeEnum = exports.FetchMarketMatchesSortEnum = exports.FetchMarketMatchesRelationEnum = exports.FetchMarketMatchesExchangeEnum = exports.FetchMarketSearchInEnum = exports.FetchMarketStatusEnum = exports.FetchMarketSortEnum = exports.FetchMarketExchangeEnum = exports.FetchHedgesSortEnum = exports.FetchHedgesRelationEnum = exports.FetchHedgesExchangeEnum = exports.FetchEventsPaginatedExchangeEnum = exports.FetchEventsSearchInEnum = exports.FetchEventsStatusEnum = exports.FetchEventsSortEnum = exports.FetchEventsExchangeEnum = exports.FetchEventMatchesRelationEnum = exports.FetchEventMatchesExchangeEnum = exports.FetchEventSearchInEnum = exports.FetchEventStatusEnum = exports.FetchEventSortEnum = exports.FetchEventExchangeEnum = exports.FetchClosedOrdersExchangeEnum = exports.FetchBalanceExchangeEnum = exports.FetchArbitrageRelationsEnum = exports.FetchArbitrageExchangeEnum = exports.FetchAllOrdersExchangeEnum = exports.CreateOrderOperationExchangeEnum = exports.CompareMarketPricesOperationExchangeEnum = exports.CloseOperationExchangeEnum = exports.CancelOrderOperationExchangeEnum = exports.BuildOrderOperationExchangeEnum = exports.DefaultApi = void 0;
-exports.WatchTradesOperationExchangeEnum = exports.WatchOrderBookOperationExchangeEnum = exports.WatchAddressOperationExchangeEnum = exports.UnwatchOrderBookOperationExchangeEnum = exports.UnwatchAddressOperationExchangeEnum = exports.SubmitOrderOperationExchangeEnum = exports.LoadMarketsOperationExchangeEnum = exports.GetExecutionPriceDetailedOperationExchangeEnum = exports.GetExecutionPriceOperationExchangeEnum = exports.FilterMarketsOperationExchangeEnum = exports.FilterEventsOperationExchangeEnum = exports.FetchTradesExchangeEnum = void 0;
+exports.WatchTradesOperationExchangeEnum = exports.WatchOrderBooksOperationExchangeEnum = exports.WatchOrderBookOperationExchangeEnum = exports.WatchAddressOperationExchangeEnum = exports.UnwatchOrderBookOperationExchangeEnum = exports.UnwatchAddressOperationExchangeEnum = exports.SubmitOrderOperationExchangeEnum = exports.LoadMarketsOperationExchangeEnum = exports.GetExecutionPriceDetailedOperationExchangeEnum = exports.GetExecutionPriceOperationExchangeEnum = exports.FilterMarketsOperationExchangeEnum = exports.FilterEventsOperationExchangeEnum = exports.FetchTradesExchangeEnum = void 0;
 const runtime = __importStar(require("../runtime"));
 const index_1 = require("../models/index");
 /**
@@ -1593,6 +1593,36 @@ 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: (0, index_1.WatchOrderBooksRequestToJSON)(requestParameters['watchOrderBooksRequest']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.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
@@ -2465,6 +2495,23 @@ exports.WatchOrderBookOperationExchangeEnum = {
     PolymarketUs: 'polymarket_us',
     Router: 'router'
 };
+/**
+ * @export
+ */
+exports.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/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';
+import type { OrderBook } from './OrderBook';
+/**
+ *
+ * @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/generated/src/models/WatchOrderBooks200Response.js

@@ -0,0 +1,55 @@
+"use strict";
+/* 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfWatchOrderBooks200Response = instanceOfWatchOrderBooks200Response;
+exports.WatchOrderBooks200ResponseFromJSON = WatchOrderBooks200ResponseFromJSON;
+exports.WatchOrderBooks200ResponseFromJSONTyped = WatchOrderBooks200ResponseFromJSONTyped;
+exports.WatchOrderBooks200ResponseToJSON = WatchOrderBooks200ResponseToJSON;
+exports.WatchOrderBooks200ResponseToJSONTyped = WatchOrderBooks200ResponseToJSONTyped;
+const runtime_1 = require("../runtime");
+const ErrorDetail_1 = require("./ErrorDetail");
+const OrderBook_1 = require("./OrderBook");
+/**
+ * Check if a given object implements the WatchOrderBooks200Response interface.
+ */
+function instanceOfWatchOrderBooks200Response(value) {
+    return true;
+}
+function WatchOrderBooks200ResponseFromJSON(json) {
+    return WatchOrderBooks200ResponseFromJSONTyped(json, false);
+}
+function WatchOrderBooks200ResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'success': json['success'] == null ? undefined : json['success'],
+        'error': json['error'] == null ? undefined : (0, ErrorDetail_1.ErrorDetailFromJSON)(json['error']),
+        'data': json['data'] == null ? undefined : ((0, runtime_1.mapValues)(json['data'], OrderBook_1.OrderBookFromJSON)),
+    };
+}
+function WatchOrderBooks200ResponseToJSON(json) {
+    return WatchOrderBooks200ResponseToJSONTyped(json, false);
+}
+function WatchOrderBooks200ResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'success': value['success'],
+        'error': (0, ErrorDetail_1.ErrorDetailToJSON)(value['error']),
+        'data': value['data'] == null ? undefined : ((0, runtime_1.mapValues)(value['data'], OrderBook_1.OrderBookToJSON)),
+    };
+}

package/dist/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';
+import type { WatchOrderBooksRequestArgsInner } from './WatchOrderBooksRequestArgsInner';
+/**
+ *
+ * @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/generated/src/models/WatchOrderBooksRequest.js

@@ -0,0 +1,54 @@
+"use strict";
+/* 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfWatchOrderBooksRequest = instanceOfWatchOrderBooksRequest;
+exports.WatchOrderBooksRequestFromJSON = WatchOrderBooksRequestFromJSON;
+exports.WatchOrderBooksRequestFromJSONTyped = WatchOrderBooksRequestFromJSONTyped;
+exports.WatchOrderBooksRequestToJSON = WatchOrderBooksRequestToJSON;
+exports.WatchOrderBooksRequestToJSONTyped = WatchOrderBooksRequestToJSONTyped;
+const ExchangeCredentials_1 = require("./ExchangeCredentials");
+const WatchOrderBooksRequestArgsInner_1 = require("./WatchOrderBooksRequestArgsInner");
+/**
+ * Check if a given object implements the WatchOrderBooksRequest interface.
+ */
+function instanceOfWatchOrderBooksRequest(value) {
+    if (!('args' in value) || value['args'] === undefined)
+        return false;
+    return true;
+}
+function WatchOrderBooksRequestFromJSON(json) {
+    return WatchOrderBooksRequestFromJSONTyped(json, false);
+}
+function WatchOrderBooksRequestFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'args': (json['args'].map(WatchOrderBooksRequestArgsInner_1.WatchOrderBooksRequestArgsInnerFromJSON)),
+        'credentials': json['credentials'] == null ? undefined : (0, ExchangeCredentials_1.ExchangeCredentialsFromJSON)(json['credentials']),
+    };
+}
+function WatchOrderBooksRequestToJSON(json) {
+    return WatchOrderBooksRequestToJSONTyped(json, false);
+}
+function WatchOrderBooksRequestToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'args': (value['args'].map(WatchOrderBooksRequestArgsInner_1.WatchOrderBooksRequestArgsInnerToJSON)),
+        'credentials': (0, ExchangeCredentials_1.ExchangeCredentialsToJSON)(value['credentials']),
+    };
+}

package/dist/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;