pmxtjs 2.41.0 → 2.41.3

package/generated/src/apis/DefaultApi.ts

@@ -57,14 +57,8 @@ import type {
   TestDummyMethodRequest,
   UnifiedEvent,
   UnifiedMarket,
-  UnwatchAddressRequest,
-  UnwatchOrderBookRequest,
   WatchAddress200Response,
-  WatchAddressRequest,
-  WatchOrderBookRequest,
   WatchOrderBooks200Response,
-  WatchOrderBooksRequest,
-  WatchTradesRequest,
 } from '../models/index';
 import {
     BaseResponseFromJSON,
@@ -151,22 +145,10 @@ import {
     UnifiedEventToJSON,
     UnifiedMarketFromJSON,
     UnifiedMarketToJSON,
-    UnwatchAddressRequestFromJSON,
-    UnwatchAddressRequestToJSON,
-    UnwatchOrderBookRequestFromJSON,
-    UnwatchOrderBookRequestToJSON,
     WatchAddress200ResponseFromJSON,
     WatchAddress200ResponseToJSON,
-    WatchAddressRequestFromJSON,
-    WatchAddressRequestToJSON,
-    WatchOrderBookRequestFromJSON,
-    WatchOrderBookRequestToJSON,
     WatchOrderBooks200ResponseFromJSON,
     WatchOrderBooks200ResponseToJSON,
-    WatchOrderBooksRequestFromJSON,
-    WatchOrderBooksRequestToJSON,
-    WatchTradesRequestFromJSON,
-    WatchTradesRequestToJSON,
 } from '../models/index';
 
 export interface BuildOrderOperationRequest {
@@ -461,34 +443,28 @@ export interface TestDummyMethodOperationRequest {
     testDummyMethodRequest?: TestDummyMethodRequest;
 }
 
-export interface UnwatchAddressOperationRequest {
-    exchange: UnwatchAddressOperationExchangeEnum;
-    unwatchAddressRequest?: UnwatchAddressRequest;
+export interface UnwatchAddressRequest {
+    exchange: UnwatchAddressExchangeEnum;
 }
 
-export interface UnwatchOrderBookOperationRequest {
-    exchange: UnwatchOrderBookOperationExchangeEnum;
-    unwatchOrderBookRequest?: UnwatchOrderBookRequest;
+export interface UnwatchOrderBookRequest {
+    exchange: UnwatchOrderBookExchangeEnum;
 }
 
-export interface WatchAddressOperationRequest {
-    exchange: WatchAddressOperationExchangeEnum;
-    watchAddressRequest?: WatchAddressRequest;
+export interface WatchAddressRequest {
+    exchange: WatchAddressExchangeEnum;
 }
 
-export interface WatchOrderBookOperationRequest {
-    exchange: WatchOrderBookOperationExchangeEnum;
-    watchOrderBookRequest?: WatchOrderBookRequest;
+export interface WatchOrderBookRequest {
+    exchange: WatchOrderBookExchangeEnum;
 }
 
-export interface WatchOrderBooksOperationRequest {
-    exchange: WatchOrderBooksOperationExchangeEnum;
-    watchOrderBooksRequest?: WatchOrderBooksRequest;
+export interface WatchOrderBooksRequest {
+    exchange: WatchOrderBooksExchangeEnum;
 }
 
-export interface WatchTradesOperationRequest {
-    exchange: WatchTradesOperationExchangeEnum;
-    watchTradesRequest?: WatchTradesRequest;
+export interface WatchTradesRequest {
+    exchange: WatchTradesExchangeEnum;
 }
 
 /**
@@ -2507,10 +2483,10 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Stop watching a previously registered wallet address and release its resource updates.
+     * Stop watching a previously registered wallet address and release its resource updates.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Unwatch Address
      */
-    async unwatchAddressRaw(requestParameters: UnwatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
+    async unwatchAddressRaw(requestParameters: UnwatchAddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -2522,8 +2498,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
         let urlPath = `/api/{exchange}/unwatchAddress`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
@@ -2533,26 +2507,25 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: UnwatchAddressRequestToJSON(requestParameters['unwatchAddressRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => BaseResponseFromJSON(jsonValue));
     }
 
     /**
-     * Stop watching a previously registered wallet address and release its resource updates.
+     * Stop watching a previously registered wallet address and release its resource updates.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Unwatch Address
      */
-    async unwatchAddress(requestParameters: UnwatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
+    async unwatchAddress(requestParameters: UnwatchAddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
         const response = await this.unwatchAddressRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Unsubscribe from a previously watched order book stream.
+     * Unsubscribe from a previously watched order book stream.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Unwatch Order Book
      */
-    async unwatchOrderBookRaw(requestParameters: UnwatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
+    async unwatchOrderBookRaw(requestParameters: UnwatchOrderBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -2564,8 +2537,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
         let urlPath = `/api/{exchange}/unwatchOrderBook`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
@@ -2575,26 +2546,25 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: UnwatchOrderBookRequestToJSON(requestParameters['unwatchOrderBookRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => BaseResponseFromJSON(jsonValue));
     }
 
     /**
-     * Unsubscribe from a previously watched order book stream.
+     * Unsubscribe from a previously watched order book stream.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Unwatch Order Book
      */
-    async unwatchOrderBook(requestParameters: UnwatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
+    async unwatchOrderBook(requestParameters: UnwatchOrderBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
         const response = await this.unwatchOrderBookRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Watch Address
      */
-    async watchAddressRaw(requestParameters: WatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchAddress200Response>> {
+    async watchAddressRaw(requestParameters: WatchAddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchAddress200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -2606,8 +2576,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
         let urlPath = `/api/{exchange}/watchAddress`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
@@ -2617,26 +2585,25 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: WatchAddressRequestToJSON(requestParameters['watchAddressRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => WatchAddress200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Watch Address
      */
-    async watchAddress(requestParameters: WatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchAddress200Response> {
+    async watchAddress(requestParameters: WatchAddressRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchAddress200Response> {
         const response = await this.watchAddressRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Watch order book updates in real-time via WebSocket. Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     * Watch order book updates in real-time via WebSocket. Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Watch Order Book
      */
-    async watchOrderBookRaw(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOrderBook200Response>> {
+    async watchOrderBookRaw(requestParameters: WatchOrderBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOrderBook200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -2648,8 +2615,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
         let urlPath = `/api/{exchange}/watchOrderBook`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
@@ -2659,26 +2624,25 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: WatchOrderBookRequestToJSON(requestParameters['watchOrderBookRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => FetchOrderBook200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Watch order book updates in real-time via WebSocket. Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     * Watch order book updates in real-time via WebSocket. Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Watch Order Book
      */
-    async watchOrderBook(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOrderBook200Response> {
+    async watchOrderBook(requestParameters: WatchOrderBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOrderBook200Response> {
         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 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.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBooks\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBooks\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Watch Order Books
      */
-    async watchOrderBooksRaw(requestParameters: WatchOrderBooksOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchOrderBooks200Response>> {
+    async watchOrderBooksRaw(requestParameters: WatchOrderBooksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchOrderBooks200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -2690,8 +2654,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
         let urlPath = `/api/{exchange}/watchOrderBooks`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
@@ -2701,26 +2663,25 @@ export class DefaultApi extends runtime.BaseAPI {
             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 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.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBooks\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBooks\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Watch Order Books
      */
-    async watchOrderBooks(requestParameters: WatchOrderBooksOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchOrderBooks200Response> {
+    async watchOrderBooks(requestParameters: WatchOrderBooksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchOrderBooks200Response> {
         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 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).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchTrades\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchTrades\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Watch Trades
      */
-    async watchTradesRaw(requestParameters: WatchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchTrades200Response>> {
+    async watchTradesRaw(requestParameters: WatchTradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchTrades200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -2732,8 +2693,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
         let urlPath = `/api/{exchange}/watchTrades`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
@@ -2743,17 +2702,16 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: WatchTradesRequestToJSON(requestParameters['watchTradesRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => FetchTrades200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * 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 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).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchTrades\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchTrades\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
      * Watch Trades
      */
-    async watchTrades(requestParameters: WatchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchTrades200Response> {
+    async watchTrades(requestParameters: WatchTradesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchTrades200Response> {
         const response = await this.watchTradesRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -3521,7 +3479,7 @@ export type TestDummyMethodOperationExchangeEnum = typeof TestDummyMethodOperati
 /**
  * @export
  */
-export const UnwatchAddressOperationExchangeEnum = {
+export const UnwatchAddressExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     KalshiDemo: 'kalshi-demo',
@@ -3535,11 +3493,11 @@ export const UnwatchAddressOperationExchangeEnum = {
     PolymarketUs: 'polymarket_us',
     Router: 'router'
 } as const;
-export type UnwatchAddressOperationExchangeEnum = typeof UnwatchAddressOperationExchangeEnum[keyof typeof UnwatchAddressOperationExchangeEnum];
+export type UnwatchAddressExchangeEnum = typeof UnwatchAddressExchangeEnum[keyof typeof UnwatchAddressExchangeEnum];
 /**
  * @export
  */
-export const UnwatchOrderBookOperationExchangeEnum = {
+export const UnwatchOrderBookExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     KalshiDemo: 'kalshi-demo',
@@ -3553,11 +3511,11 @@ export const UnwatchOrderBookOperationExchangeEnum = {
     PolymarketUs: 'polymarket_us',
     Router: 'router'
 } as const;
-export type UnwatchOrderBookOperationExchangeEnum = typeof UnwatchOrderBookOperationExchangeEnum[keyof typeof UnwatchOrderBookOperationExchangeEnum];
+export type UnwatchOrderBookExchangeEnum = typeof UnwatchOrderBookExchangeEnum[keyof typeof UnwatchOrderBookExchangeEnum];
 /**
  * @export
  */
-export const WatchAddressOperationExchangeEnum = {
+export const WatchAddressExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     KalshiDemo: 'kalshi-demo',
@@ -3571,11 +3529,11 @@ export const WatchAddressOperationExchangeEnum = {
     PolymarketUs: 'polymarket_us',
     Router: 'router'
 } as const;
-export type WatchAddressOperationExchangeEnum = typeof WatchAddressOperationExchangeEnum[keyof typeof WatchAddressOperationExchangeEnum];
+export type WatchAddressExchangeEnum = typeof WatchAddressExchangeEnum[keyof typeof WatchAddressExchangeEnum];
 /**
  * @export
  */
-export const WatchOrderBookOperationExchangeEnum = {
+export const WatchOrderBookExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     KalshiDemo: 'kalshi-demo',
@@ -3589,11 +3547,11 @@ export const WatchOrderBookOperationExchangeEnum = {
     PolymarketUs: 'polymarket_us',
     Router: 'router'
 } as const;
-export type WatchOrderBookOperationExchangeEnum = typeof WatchOrderBookOperationExchangeEnum[keyof typeof WatchOrderBookOperationExchangeEnum];
+export type WatchOrderBookExchangeEnum = typeof WatchOrderBookExchangeEnum[keyof typeof WatchOrderBookExchangeEnum];
 /**
  * @export
  */
-export const WatchOrderBooksOperationExchangeEnum = {
+export const WatchOrderBooksExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     KalshiDemo: 'kalshi-demo',
@@ -3607,11 +3565,11 @@ export const WatchOrderBooksOperationExchangeEnum = {
     PolymarketUs: 'polymarket_us',
     Router: 'router'
 } as const;
-export type WatchOrderBooksOperationExchangeEnum = typeof WatchOrderBooksOperationExchangeEnum[keyof typeof WatchOrderBooksOperationExchangeEnum];
+export type WatchOrderBooksExchangeEnum = typeof WatchOrderBooksExchangeEnum[keyof typeof WatchOrderBooksExchangeEnum];
 /**
  * @export
  */
-export const WatchTradesOperationExchangeEnum = {
+export const WatchTradesExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     KalshiDemo: 'kalshi-demo',
@@ -3625,4 +3583,4 @@ export const WatchTradesOperationExchangeEnum = {
     PolymarketUs: 'polymarket_us',
     Router: 'router'
 } as const;
-export type WatchTradesOperationExchangeEnum = typeof WatchTradesOperationExchangeEnum[keyof typeof WatchTradesOperationExchangeEnum];
+export type WatchTradesExchangeEnum = typeof WatchTradesExchangeEnum[keyof typeof WatchTradesExchangeEnum];

package/generated/src/models/index.ts

@@ -87,15 +87,6 @@ export * from './Trade';
 export * from './TradesParams';
 export * from './UnifiedEvent';
 export * from './UnifiedMarket';
-export * from './UnwatchAddressRequest';
-export * from './UnwatchOrderBookRequest';
 export * from './UserTrade';
 export * from './WatchAddress200Response';
-export * from './WatchAddressRequest';
-export * from './WatchAddressRequestArgsInner';
-export * from './WatchOrderBookRequest';
-export * from './WatchOrderBookRequestArgsInner';
 export * from './WatchOrderBooks200Response';
-export * from './WatchOrderBooksRequest';
-export * from './WatchOrderBooksRequestArgsInner';
-export * from './WatchTradesRequest';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxtjs",
-  "version": "2.41.0",
+  "version": "2.41.3",
   "description": "Unified prediction market data API - The ccxt for prediction markets",
   "author": "PMXT Contributors",
   "repository": {
@@ -43,7 +43,7 @@
     "unified"
   ],
   "dependencies": {
-    "pmxt-core": "2.41.0",
+    "pmxt-core": "2.41.3",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/pmxt/client.ts

@@ -230,6 +230,8 @@ export abstract class Exchange {
     protected serverManager: ServerManager;
     protected initPromise: Promise<void>;
     protected isHosted: boolean;
+    private _hostedAccount?: { depositWallet?: string; signatureType?: number };
+    private _accountDiscoveryPromise?: Promise<void>;
 
     /**
      * Sticky flag: set to `true` the first time a GET read is rejected by
@@ -1601,26 +1603,26 @@ export abstract class Exchange {
      * Requires hosted mode (`pmxtApiKey` set).
      *
      * @param venues - Optional venue filter (e.g. ["polymarket", "limitless"])
-     * @returns Next firehose event with source, symbol, and orderbook
+     * @returns Next event with source, symbol, and orderbook
      *
      * @example
      * ```typescript
      * const poly = new Polymarket({ pmxtApiKey: "pmxt_xxx" });
      * while (true) {
-     *   const event = await poly.firehose();
+     *   const event = await poly.watchAllOrderBooks();
      *   console.log(event.source, event.symbol, event.orderbook.bids[0]);
      * }
      * ```
      */
-    async firehose(venues?: string[]): Promise<FirehoseEvent> {
+    async watchAllOrderBooks(venues?: string[]): Promise<FirehoseEvent> {
         await this.initPromise;
 
         if (!this.isHosted) {
-            throw new PmxtError("firehose() requires hosted mode (set pmxtApiKey)");
+            throw new PmxtError("watchAllOrderBooks() requires hosted mode (set pmxtApiKey)");
         }
 
         const args: any[] = venues ? [venues] : [];
-        const wsData = await this.watchViaWs("firehose", args);
+        const wsData = await this.watchViaWs("watchAllOrderBooks", args);
         if (wsData !== null) {
             return {
                 source: (wsData as any)._source || "",
@@ -1629,7 +1631,12 @@ export abstract class Exchange {
             };
         }
 
-        throw new PmxtError("firehose() requires WebSocket transport — connection failed");
+        throw new PmxtError("watchAllOrderBooks() requires WebSocket transport — connection failed");
+    }
+
+    /** @deprecated Use {@link watchAllOrderBooks} instead. */
+    async firehose(venues?: string[]): Promise<FirehoseEvent> {
+        return this.watchAllOrderBooks(venues);
     }
 
     /**
@@ -1850,12 +1857,73 @@ export abstract class Exchange {
         }
     }
 
+    private async _discoverHostedAccount(): Promise<void> {
+        if (this._hostedAccount) return;
+        if (!this._accountDiscoveryPromise) {
+            this._accountDiscoveryPromise = (async () => {
+                try {
+                    const res = await this.fetchWithRetry(
+                        `${this.resolveBaseUrl()}/v0/account`,
+                        { method: 'GET', headers: { ...this.getAuthHeaders() } },
+                    );
+                    if (res.ok) {
+                        const body = await res.json();
+                        this._hostedAccount = { depositWallet: body.deposit_wallet, signatureType: body.signature_type };
+                    } else { this._hostedAccount = {}; }
+                } catch { this._hostedAccount = {}; }
+            })();
+        }
+        await this._accountDiscoveryPromise;
+    }
+
+    private async _executeSorOrder(params: any): Promise<Order> {
+        await this._discoverHostedAccount();
+
+        const buildRes = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/sor/buildOrder`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+            body: JSON.stringify({ args: [params] }),
+        });
+        if (!buildRes.ok) throw new PmxtError(`buildOrder failed: ${await buildRes.text()}`);
+        const buildJson = await buildRes.json();
+        const { orderId, legs } = buildJson.data || buildJson;
+
+        const fills: any[] = [];
+        for (const leg of legs) {
+            try {
+                const { Polymarket, Limitless } = require('pmxt-core');
+                const VenueClass = leg.venue === 'polymarket' ? Polymarket : leg.venue === 'limitless' ? Limitless : null;
+                if (!VenueClass) throw new Error(`unsupported venue: ${leg.venue}`);
+
+                const venueOpts: any = { privateKey: this.privateKey };
+                if (leg.venue === 'polymarket' && this._hostedAccount?.depositWallet) {
+                    venueOpts.funderAddress = this._hostedAccount.depositWallet;
+                    venueOpts.signatureType = this._hostedAccount.signatureType || 3;
+                }
+                const venue = new VenueClass(venueOpts);
+                const order = await venue.createOrder({ outcomeId: leg.tokenId, side: leg.side, amount: leg.shares, price: leg.price });
+                const filledShares = order.filled || 0;
+                fills.push({ venue: leg.venue, venueOrderId: order.id, venueMarketId: leg.venueMarketId, venueOutcomeId: leg.venueOutcomeId, shares: filledShares > 0 ? filledShares : leg.shares, price: order.price || leg.price, status: filledShares > 0 ? 'filled' : 'open' });
+            } catch (err: any) {
+                fills.push({ venue: leg.venue, venueMarketId: leg.venueMarketId, venueOutcomeId: leg.venueOutcomeId, shares: leg.shares, price: leg.price, status: 'failed', error: err.message });
+            }
+        }
+
+        const submitRes = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/sor/submitOrder`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+            body: JSON.stringify({ args: [{ orderId, fills }] }),
+        });
+        if (!submitRes.ok) throw new PmxtError(`submitOrder failed: ${await submitRes.text()}`);
+        const submitJson = await submitRes.json();
+        const submitData = submitJson.data || submitJson;
+        if (submitData.status === 'failed' && submitData.errors?.length) {
+            throw new PmxtError(submitData.errors[0]);
+        }
+        return convertOrder(submitData);
+    }
+
     /**
-     * Create a new order.
-     * 
-     * @param params - Order parameters
-     * @returns Created order
-     * 
      * @example
      * ```typescript
      * const order = await exchange.createOrder({
@@ -1870,6 +1938,9 @@ export abstract class Exchange {
      */
     async createOrder(params: any): Promise<Order> {
         if (this.isHosted) {
+            if (this.exchangeName === 'sor' && this.privateKey) {
+                return this._executeSorOrder(params);
+            }
             throw new PmxtError(
                 "Trade execution is not available through the hosted API. " +
                 "Use the local PMXT SDK with your venue credentials instead. " +

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

@@ -1,39 +0,0 @@
-/**
- * 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';
-/**
- *
- * @export
- * @interface UnwatchAddressRequest
- */
-export interface UnwatchAddressRequest {
-    /**
-     *
-     * @type {Array<string>}
-     * @memberof UnwatchAddressRequest
-     */
-    args: Array<string>;
-    /**
-     *
-     * @type {ExchangeCredentials}
-     * @memberof UnwatchAddressRequest
-     */
-    credentials?: ExchangeCredentials;
-}
-/**
- * Check if a given object implements the UnwatchAddressRequest interface.
- */
-export declare function instanceOfUnwatchAddressRequest(value: object): value is UnwatchAddressRequest;
-export declare function UnwatchAddressRequestFromJSON(json: any): UnwatchAddressRequest;
-export declare function UnwatchAddressRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): UnwatchAddressRequest;
-export declare function UnwatchAddressRequestToJSON(json: any): UnwatchAddressRequest;
-export declare function UnwatchAddressRequestToJSONTyped(value?: UnwatchAddressRequest | null, ignoreDiscriminator?: boolean): any;