pmxt-core 2.38.0 → 2.39.0

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/opinion/opinion-openapi.yaml
- * Generated at: 2026-05-08T19:42:37.556Z
+ * Generated at: 2026-05-08T20:27:07.094Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const opinionApiSpec: {

package/dist/exchanges/opinion/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.opinionApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/opinion/opinion-openapi.yaml
- * Generated at: 2026-05-08T19:42:37.556Z
+ * Generated at: 2026-05-08T20:27:07.094Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.opinionApiSpec = {

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

@@ -21,8 +21,8 @@ export declare class OpinionExchange extends PredictionMarketExchange {
     protected mapImplicitApiError(error: any): any;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     fetchPositions(): Promise<Position[]>;
     fetchOrder(orderId: string): Promise<Order>;
@@ -33,8 +33,8 @@ export declare class OpinionExchange extends PredictionMarketExchange {
     submitOrder(built: BuiltOrder): Promise<Order>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
-    watchOrderBook(id: string): Promise<OrderBook>;
-    watchTrades(id: string): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchTrades(outcomeId: string): Promise<Trade[]>;
     close(): Promise<void>;
     /**
      * Resolve an ID (which may be a token/outcome ID or a numeric market ID string)

package/dist/exchanges/opinion/index.js

@@ -165,13 +165,13 @@ class OpinionExchange extends BaseExchange_1.PredictionMarketExchange {
         await this.enrichPrices(allMarkets);
         return events;
     }
-    async fetchOHLCV(id, params) {
-        const rawPoints = await this.fetcher.fetchRawOHLCV(id, params);
+    async fetchOHLCV(outcomeId, params) {
+        const rawPoints = await this.fetcher.fetchRawOHLCV(outcomeId, params);
         return this.normalizer.normalizeOHLCV({ history: rawPoints }, params);
     }
-    async fetchOrderBook(id) {
-        const raw = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(raw, id);
+    async fetchOrderBook(outcomeId) {
+        const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
     }
     // -------------------------------------------------------------------------
     // User Data (fetcher -> normalizer)
@@ -323,14 +323,14 @@ class OpinionExchange extends BaseExchange_1.PredictionMarketExchange {
     // -------------------------------------------------------------------------
     // WebSocket
     // -------------------------------------------------------------------------
-    async watchOrderBook(id) {
+    async watchOrderBook(outcomeId) {
         const ws = this.ensureWebSocket();
-        const marketId = this.resolveMarketId(id);
+        const marketId = this.resolveMarketId(outcomeId);
         return ws.watchOrderBook(marketId);
     }
-    async watchTrades(id) {
+    async watchTrades(outcomeId) {
         const ws = this.ensureWebSocket();
-        const marketId = this.resolveMarketId(id);
+        const marketId = this.resolveMarketId(outcomeId);
         return ws.watchTrades(marketId);
     }
     async close() {

package/dist/exchanges/polymarket/api-clob.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-05-08T19:42:37.506Z
+ * Generated at: 2026-05-08T20:27:07.017Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketClobSpec: {

package/dist/exchanges/polymarket/api-clob.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketClobSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-05-08T19:42:37.506Z
+ * Generated at: 2026-05-08T20:27:07.017Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketClobSpec = {

package/dist/exchanges/polymarket/api-data.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-05-08T19:42:37.518Z
+ * Generated at: 2026-05-08T20:27:07.042Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketDataSpec: {

package/dist/exchanges/polymarket/api-data.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketDataSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-05-08T19:42:37.518Z
+ * Generated at: 2026-05-08T20:27:07.042Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketDataSpec = {

package/dist/exchanges/polymarket/api-gamma.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-05-08T19:42:37.516Z
+ * Generated at: 2026-05-08T20:27:07.038Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketGammaSpec: {

package/dist/exchanges/polymarket/api-gamma.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketGammaSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-05-08T19:42:37.516Z
+ * Generated at: 2026-05-08T20:27:07.038Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

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

@@ -26,9 +26,9 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
      * a privateKey was provided (not apiKey/apiSecret/passphrase).
      */
     initAuth(): Promise<void>;
-    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
-    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     /**
      * Pre-warm the SDK's internal caches for a market outcome.
      *
@@ -49,9 +49,9 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     fetchPositions(address?: string): Promise<Position[]>;
     fetchBalance(address?: string): Promise<Balance[]>;
-    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
-    unwatchOrderBook(id: string): Promise<void>;
-    watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
+    unwatchOrderBook(outcomeId: string): Promise<void>;
+    watchTrades(outcomeId: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
     watchAddress(address: string, types?: SubscriptionOption[]): Promise<SubscribedAddressSnapshot>;
     unwatchAddress(address: string): Promise<void>;
     close(): Promise<void>;

package/dist/exchanges/polymarket/index.js

@@ -101,29 +101,29 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
         };
         this.cachedAddress = auth.getFunderAddress();
     }
-    async fetchOHLCV(id, params) {
-        (0, validation_1.validateIdFormat)(id, 'OHLCV');
-        (0, validation_1.validateOutcomeId)(id, 'OHLCV');
+    async fetchOHLCV(outcomeId, params) {
+        (0, validation_1.validateIdFormat)(outcomeId, 'OHLCV');
+        (0, validation_1.validateOutcomeId)(outcomeId, 'OHLCV');
         if (!params.resolution) {
             throw new Error('fetchOHLCV requires a resolution parameter. Use OHLCVParams with resolution specified.');
         }
-        const raw = await this.fetcher.fetchRawOHLCV(id, params);
+        const raw = await this.fetcher.fetchRawOHLCV(outcomeId, params);
         return this.normalizer.normalizeOHLCV(raw, params);
     }
-    async fetchOrderBook(id) {
-        (0, validation_1.validateIdFormat)(id, 'OrderBook');
-        (0, validation_1.validateOutcomeId)(id, 'OrderBook');
-        const raw = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(raw, id);
+    async fetchOrderBook(outcomeId) {
+        (0, validation_1.validateIdFormat)(outcomeId, 'OrderBook');
+        (0, validation_1.validateOutcomeId)(outcomeId, 'OrderBook');
+        const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
     }
-    async fetchTrades(id, params) {
-        (0, validation_1.validateIdFormat)(id, 'Trades');
-        (0, validation_1.validateOutcomeId)(id, 'Trades');
+    async fetchTrades(outcomeId, params) {
+        (0, validation_1.validateIdFormat)(outcomeId, 'Trades');
+        (0, validation_1.validateOutcomeId)(outcomeId, 'Trades');
         if ('resolution' in params && params.resolution !== undefined) {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
                 'It will be removed in v3.0.0. Please remove it from your code.');
         }
-        const rawTrades = await this.fetcher.fetchRawTrades(id, params);
+        const rawTrades = await this.fetcher.fetchRawTrades(outcomeId, params);
         const mappedTrades = rawTrades.map((raw, i) => this.normalizer.normalizeTrade(raw, i));
         if (params.limit && mappedTrades.length > params.limit) {
             return mappedTrades.slice(0, params.limit);
@@ -411,14 +411,14 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
     // ----------------------------------------------------------------------------
     // WebSocket Methods
     // ----------------------------------------------------------------------------
-    async watchOrderBook(id, limit) {
-        return this.ensureWs().watchOrderBook(id);
+    async watchOrderBook(outcomeId, limit) {
+        return this.ensureWs().watchOrderBook(outcomeId);
     }
-    async unwatchOrderBook(id) {
-        return this.ensureWs().unwatchOrderBook(id);
+    async unwatchOrderBook(outcomeId) {
+        return this.ensureWs().unwatchOrderBook(outcomeId);
     }
-    async watchTrades(id, address, since, limit) {
-        return this.ensureWs().watchTrades(id, address);
+    async watchTrades(outcomeId, address, since, limit) {
+        return this.ensureWs().watchTrades(outcomeId, address);
     }
     async watchAddress(address, types = ['trades', 'positions', 'balances']) {
         return this.ensureWs().watchAddress(address, types);

package/dist/exchanges/polymarket/websocket.d.ts

@@ -31,9 +31,9 @@ export declare class PolymarketWebSocket {
     private config;
     private initializationPromise?;
     constructor(callApi: (operationId: string, params?: Record<string, any>) => Promise<any>, config?: PolymarketWebSocketConfig);
-    watchOrderBook(id: string): Promise<OrderBook>;
-    unwatchOrderBook(id: string): Promise<void>;
-    watchTrades(id: string, address?: string): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    unwatchOrderBook(outcomeId: string): Promise<void>;
+    watchTrades(outcomeId: string, address?: string): Promise<Trade[]>;
     watchAddress(address: string, types: SubscriptionOption[]): Promise<SubscribedAddressSnapshot>;
     unwatchAddress(address: string): Promise<void>;
     close(): Promise<void>;

package/dist/exchanges/polymarket/websocket.js

@@ -68,55 +68,55 @@ class PolymarketWebSocket {
             buildActivity: goldsky_1.buildPolymarketActivity,
         });
     }
-    async watchOrderBook(id) {
+    async watchOrderBook(outcomeId) {
         await this.ensureInitialized();
         // Subscribe to the asset if not already subscribed
         const currentAssets = this.manager.getAssetIds();
-        if (!currentAssets.includes(id)) {
-            await this.manager.addSubscriptions([id]);
+        if (!currentAssets.includes(outcomeId)) {
+            await this.manager.addSubscriptions([outcomeId]);
         }
         // Return a promise that resolves on the next orderbook update
         const dataPromise = new Promise((resolve, reject) => {
-            if (!this.orderBookResolvers.has(id)) {
-                this.orderBookResolvers.set(id, []);
+            if (!this.orderBookResolvers.has(outcomeId)) {
+                this.orderBookResolvers.set(outcomeId, []);
             }
-            this.orderBookResolvers.get(id).push({ resolve, reject });
+            this.orderBookResolvers.get(outcomeId).push({ resolve, reject });
         });
-        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${id}')`);
+        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${outcomeId}')`);
     }
-    async unwatchOrderBook(id) {
+    async unwatchOrderBook(outcomeId) {
         if (!this.manager) {
             return;
         }
-        await this.manager.removeSubscriptions([id]);
+        await this.manager.removeSubscriptions([outcomeId]);
         // Clear any pending resolvers for this asset
-        const resolvers = this.orderBookResolvers.get(id);
+        const resolvers = this.orderBookResolvers.get(outcomeId);
         if (resolvers) {
-            this.orderBookResolvers = new Map([...this.orderBookResolvers].filter(([key]) => key !== id));
+            this.orderBookResolvers = new Map([...this.orderBookResolvers].filter(([key]) => key !== outcomeId));
         }
         // Remove the cached orderbook for this asset
-        if (this.orderBooks.has(id)) {
-            this.orderBooks = new Map([...this.orderBooks].filter(([key]) => key !== id));
+        if (this.orderBooks.has(outcomeId)) {
+            this.orderBooks = new Map([...this.orderBooks].filter(([key]) => key !== outcomeId));
         }
     }
-    async watchTrades(id, address) {
+    async watchTrades(outcomeId, address) {
         if (address) {
-            return this.watcher.watch(address, ['trades'], id);
+            return this.watcher.watch(address, ['trades'], outcomeId);
         }
         await this.ensureInitialized();
         // Subscribe to the asset if not already subscribed
         const currentAssets = this.manager.getAssetIds();
-        if (!currentAssets.includes(id)) {
-            await this.manager.addSubscriptions([id]);
+        if (!currentAssets.includes(outcomeId)) {
+            await this.manager.addSubscriptions([outcomeId]);
         }
         // Return a promise that resolves on the next trade
         const dataPromise = new Promise((resolve, reject) => {
-            if (!this.tradeResolvers.has(id)) {
-                this.tradeResolvers.set(id, []);
+            if (!this.tradeResolvers.has(outcomeId)) {
+                this.tradeResolvers.set(outcomeId, []);
             }
-            this.tradeResolvers.get(id).push({ resolve, reject });
+            this.tradeResolvers.get(outcomeId).push({ resolve, reject });
         });
-        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchTrades('${id}')`);
+        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchTrades('${outcomeId}')`);
     }
     async watchAddress(address, types) {
         return this.watcher.watch(address, types);

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

@@ -46,7 +46,7 @@ export declare class PolymarketUSExchange extends PredictionMarketExchange {
     private slugFromId;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
     fetchBalance(_address?: string): Promise<Balance[]>;
     fetchPositions(_address?: string): Promise<Position[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
@@ -62,7 +62,7 @@ export declare class PolymarketUSExchange extends PredictionMarketExchange {
      * method calls `requireAuth()` up front.
      */
     private ensureWs;
-    watchOrderBook(id: string, _limit?: number): Promise<OrderBook>;
-    watchTrades(id: string, _address?: string, _since?: number, _limit?: number): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string, _limit?: number): Promise<OrderBook>;
+    watchTrades(outcomeId: string, _address?: string, _since?: number, _limit?: number): Promise<Trade[]>;
     close(): Promise<void>;
 }

package/dist/exchanges/polymarket_us/index.js

@@ -166,11 +166,11 @@ class PolymarketUSExchange extends BaseExchange_1.PredictionMarketExchange {
             return events;
         });
     }
-    async fetchOrderBook(id) {
+    async fetchOrderBook(outcomeId) {
         return this.run(async () => {
-            const slug = this.slugFromId(id);
+            const slug = this.slugFromId(outcomeId);
             const book = await this.client.markets.book(slug);
-            return this.normalizer.normalizeOrderBook(book, id);
+            return this.normalizer.normalizeOrderBook(book, outcomeId);
         });
     }
     // -------------------------------------------------------------------------
@@ -321,11 +321,11 @@ class PolymarketUSExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return this.wsWrapper;
     }
-    async watchOrderBook(id, _limit) {
-        return this.run(() => this.ensureWs().watchOrderBook(id));
+    async watchOrderBook(outcomeId, _limit) {
+        return this.run(() => this.ensureWs().watchOrderBook(outcomeId));
     }
-    async watchTrades(id, _address, _since, _limit) {
-        return this.run(() => this.ensureWs().watchTrades(id));
+    async watchTrades(outcomeId, _address, _since, _limit) {
+        return this.run(() => this.ensureWs().watchTrades(outcomeId));
     }
     // -------------------------------------------------------------------------
     // Lifecycle

package/dist/exchanges/polymarket_us/websocket.d.ts

@@ -31,8 +31,8 @@ export declare class PolymarketUSWebSocket {
     private readonly orderBookResolvers;
     private readonly tradeResolvers;
     constructor(client: PolymarketUSClient, normalizer: PolymarketUSNormalizer, config?: PolymarketUSWebSocketConfig);
-    watchOrderBook(id: string): Promise<OrderBook>;
-    watchTrades(id: string): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchTrades(outcomeId: string): Promise<Trade[]>;
     close(): Promise<void>;
     private ensureInitialized;
     private handleMarketData;

package/dist/exchanges/polymarket_us/websocket.js

@@ -57,8 +57,8 @@ class PolymarketUSWebSocket {
         this.normalizer = normalizer;
         this.config = config;
     }
-    async watchOrderBook(id) {
-        const slug = slugFromId(id);
+    async watchOrderBook(outcomeId) {
+        const slug = slugFromId(outcomeId);
         await this.ensureInitialized();
         if (!this.bookSubscriptions.has(slug)) {
             this.bookSubscriptions.add(slug);
@@ -69,10 +69,10 @@ class PolymarketUSWebSocket {
             queue.push({ resolve, reject });
             this.orderBookResolvers.set(slug, queue);
         });
-        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${id}')`);
+        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${outcomeId}')`);
     }
-    async watchTrades(id) {
-        const slug = slugFromId(id);
+    async watchTrades(outcomeId) {
+        const slug = slugFromId(outcomeId);
         await this.ensureInitialized();
         if (!this.tradeSubscriptions.has(slug)) {
             this.tradeSubscriptions.add(slug);
@@ -83,7 +83,7 @@ class PolymarketUSWebSocket {
             queue.push({ resolve, reject });
             this.tradeResolvers.set(slug, queue);
         });
-        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchTrades('${id}')`);
+        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchTrades('${outcomeId}')`);
     }
     async close() {
         if (this.socket) {

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-05-08T19:42:37.540Z
+ * Generated at: 2026-05-08T20:27:07.084Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const probableApiSpec: {

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-05-08T19:42:37.540Z
+ * Generated at: 2026-05-08T20:27:07.084Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

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

@@ -27,10 +27,10 @@ export declare class ProbableExchange extends PredictionMarketExchange {
      * @returns The UnifiedEvent, or null if not found
      */
     getEventBySlug(slug: string): Promise<UnifiedEvent | null>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
-    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
-    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     /**
      * Cancel an order.
@@ -46,6 +46,6 @@ export declare class ProbableExchange extends PredictionMarketExchange {
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     fetchPositions(): Promise<Position[]>;
     fetchBalance(): Promise<Balance[]>;
-    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
     close(): Promise<void>;
 }

package/dist/exchanges/probable/index.js

@@ -116,15 +116,15 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return event;
     }
-    async fetchOrderBook(id) {
-        const raw = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(raw, id);
+    async fetchOrderBook(outcomeId) {
+        const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
     }
-    async fetchOHLCV(id, params) {
+    async fetchOHLCV(outcomeId, params) {
         if (!params.resolution) {
             throw new Error('fetchOHLCV requires a resolution parameter.');
         }
-        const rawPoints = await this.fetcher.fetchRawOHLCV(id, params);
+        const rawPoints = await this.fetcher.fetchRawOHLCV(outcomeId, params);
         return this.normalizer.normalizeOHLCV(rawPoints, params);
     }
     async fetchMyTrades(params) {
@@ -133,11 +133,11 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         const rawTrades = await this.fetcher.fetchRawMyTrades(params || {}, address);
         return rawTrades.map((raw, i) => this.normalizer.normalizeUserTrade(raw, i));
     }
-    async fetchTrades(id, params) {
+    async fetchTrades(outcomeId, params) {
         const auth = this.ensureAuth();
         const client = auth.getClobClient();
         // Use CLOB client directly for trades (legacy behaviour preserved)
-        const queryParams = { tokenId: id };
+        const queryParams = { tokenId: outcomeId };
         if (params.limit)
             queryParams.limit = params.limit;
         const response = await client.getTrades(queryParams);
@@ -359,11 +359,11 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
     // --------------------------------------------------------------------------
     // WebSocket Streaming (public, no auth needed)
     // --------------------------------------------------------------------------
-    async watchOrderBook(id, limit) {
+    async watchOrderBook(outcomeId, limit) {
         if (!this.ws) {
             this.ws = new websocket_1.ProbableWebSocket(this.wsConfig);
         }
-        return this.ws.watchOrderBook(id);
+        return this.ws.watchOrderBook(outcomeId);
     }
     async close() {
         if (this.ws) {

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

@@ -18,8 +18,8 @@ export declare class SmarketsExchange extends PredictionMarketExchange {
     private requireAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
-    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     fetchPositions(): Promise<Position[]>;

package/dist/exchanges/smarkets/index.js

@@ -158,16 +158,16 @@ class SmarketsExchange extends BaseExchange_1.PredictionMarketExchange {
             .filter((e) => e !== null)
             .slice(0, limit);
     }
-    async fetchOrderBook(id) {
-        const raw = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(raw, id);
+    async fetchOrderBook(outcomeId) {
+        const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
     }
-    async fetchTrades(id, params) {
+    async fetchTrades(outcomeId, params) {
         if ('resolution' in params && params.resolution !== undefined) {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
                 'It will be removed in v3.0.0. Please remove it from your code.');
         }
-        const rawActivity = await this.fetcher.fetchRawTradeActivity(id, params);
+        const rawActivity = await this.fetcher.fetchRawTradeActivity(outcomeId, params);
         return rawActivity.map((raw, i) => this.normalizer.normalizeActivityTrade(raw, i));
     }
     // -------------------------------------------------------------------------

package/dist/router/Router.d.ts

@@ -8,7 +8,7 @@ export declare class Router extends PredictionMarketExchange {
     get name(): string;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params?: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOrderBook(id: string, side?: 'yes' | 'no'): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string, side?: 'yes' | 'no'): Promise<OrderBook>;
     fetchMarketMatches(params?: FetchMarketMatchesParams): Promise<MatchResult[]>;
     /**
      * Browse mode: fetch all matched market pairs from the catalog.

package/dist/router/Router.js

@@ -64,7 +64,7 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
     // -----------------------------------------------------------------------
     // Unified orderbook (cross-exchange merge)
     // -----------------------------------------------------------------------
-    async fetchOrderBook(id, side) {
+    async fetchOrderBook(outcomeId, side) {
         const exchangeNames = Object.keys(this.exchanges);
         if (exchangeNames.length === 0) {
             throw new Error('Router requires exchange instances for fetchOrderBook. Pass exchanges in RouterOptions.');
@@ -72,7 +72,7 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         const resolvedSide = side ?? 'yes';
         // Find identity matches across venues
         const matches = await this.fetchMarketMatches({
-            marketId: id,
+            marketId: outcomeId,
             relation: 'identity',
         });
         const fetchPromises = [];
@@ -92,7 +92,7 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         for (const [name, exchange] of Object.entries(this.exchanges)) {
             if (matchedVenues.has(name))
                 continue;
-            fetchPromises.push(exchange.fetchOrderBook(id, resolvedSide).catch(() => null));
+            fetchPromises.push(exchange.fetchOrderBook(outcomeId, resolvedSide).catch(() => null));
         }
         const books = (await Promise.all(fetchPromises)).filter((b) => b !== null);
         if (books.length === 0) {