pmxtjs 2.9.2 → 2.9.3

package/generated/src/apis/DefaultApi.ts

@@ -2,7 +2,7 @@
 /* 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. 
+ * 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
  * 
@@ -16,24 +16,35 @@
 import * as runtime from '../runtime';
 import type {
   BaseResponse,
+  BuildOrder200Response,
+  BuildOrderRequest,
   CancelOrderRequest,
+  CloseRequest,
   CreateOrder200Response,
   CreateOrderRequest,
-  ErrorResponse,
+  FetchAllOrdersRequest,
   FetchBalance200Response,
+  FetchBalanceRequest,
+  FetchClosedOrdersRequest,
   FetchEvent200Response,
+  FetchEventRequest,
   FetchEvents200Response,
   FetchEventsRequest,
   FetchMarket200Response,
   FetchMarketRequest,
   FetchMarkets200Response,
+  FetchMarketsPaginated200Response,
+  FetchMarketsPaginatedRequest,
   FetchMarketsRequest,
+  FetchMyTrades200Response,
+  FetchMyTradesRequest,
   FetchOHLCV200Response,
   FetchOHLCVRequest,
   FetchOpenOrders200Response,
   FetchOpenOrdersRequest,
   FetchOrderBook200Response,
   FetchOrderBookRequest,
+  FetchOrderRequest,
   FetchPositions200Response,
   FetchPositionsRequest,
   FetchTrades200Response,
@@ -42,28 +53,42 @@ import type {
   FilterMarketsRequest,
   GetExecutionPrice200Response,
   GetExecutionPriceDetailed200Response,
+  GetExecutionPriceDetailedRequest,
   GetExecutionPriceRequest,
   HealthCheck200Response,
+  LoadMarkets200Response,
+  LoadMarketsRequest,
+  SubmitOrderRequest,
   WatchOrderBookRequest,
-  WatchPricesRequest,
   WatchTradesRequest,
-  WatchUserPositionsRequest,
 } from '../models/index';
 import {
     BaseResponseFromJSON,
     BaseResponseToJSON,
+    BuildOrder200ResponseFromJSON,
+    BuildOrder200ResponseToJSON,
+    BuildOrderRequestFromJSON,
+    BuildOrderRequestToJSON,
     CancelOrderRequestFromJSON,
     CancelOrderRequestToJSON,
+    CloseRequestFromJSON,
+    CloseRequestToJSON,
     CreateOrder200ResponseFromJSON,
     CreateOrder200ResponseToJSON,
     CreateOrderRequestFromJSON,
     CreateOrderRequestToJSON,
-    ErrorResponseFromJSON,
-    ErrorResponseToJSON,
+    FetchAllOrdersRequestFromJSON,
+    FetchAllOrdersRequestToJSON,
     FetchBalance200ResponseFromJSON,
     FetchBalance200ResponseToJSON,
+    FetchBalanceRequestFromJSON,
+    FetchBalanceRequestToJSON,
+    FetchClosedOrdersRequestFromJSON,
+    FetchClosedOrdersRequestToJSON,
     FetchEvent200ResponseFromJSON,
     FetchEvent200ResponseToJSON,
+    FetchEventRequestFromJSON,
+    FetchEventRequestToJSON,
     FetchEvents200ResponseFromJSON,
     FetchEvents200ResponseToJSON,
     FetchEventsRequestFromJSON,
@@ -74,8 +99,16 @@ import {
     FetchMarketRequestToJSON,
     FetchMarkets200ResponseFromJSON,
     FetchMarkets200ResponseToJSON,
+    FetchMarketsPaginated200ResponseFromJSON,
+    FetchMarketsPaginated200ResponseToJSON,
+    FetchMarketsPaginatedRequestFromJSON,
+    FetchMarketsPaginatedRequestToJSON,
     FetchMarketsRequestFromJSON,
     FetchMarketsRequestToJSON,
+    FetchMyTrades200ResponseFromJSON,
+    FetchMyTrades200ResponseToJSON,
+    FetchMyTradesRequestFromJSON,
+    FetchMyTradesRequestToJSON,
     FetchOHLCV200ResponseFromJSON,
     FetchOHLCV200ResponseToJSON,
     FetchOHLCVRequestFromJSON,
@@ -88,6 +121,8 @@ import {
     FetchOrderBook200ResponseToJSON,
     FetchOrderBookRequestFromJSON,
     FetchOrderBookRequestToJSON,
+    FetchOrderRequestFromJSON,
+    FetchOrderRequestToJSON,
     FetchPositions200ResponseFromJSON,
     FetchPositions200ResponseToJSON,
     FetchPositionsRequestFromJSON,
@@ -104,28 +139,37 @@ import {
     GetExecutionPrice200ResponseToJSON,
     GetExecutionPriceDetailed200ResponseFromJSON,
     GetExecutionPriceDetailed200ResponseToJSON,
+    GetExecutionPriceDetailedRequestFromJSON,
+    GetExecutionPriceDetailedRequestToJSON,
     GetExecutionPriceRequestFromJSON,
     GetExecutionPriceRequestToJSON,
     HealthCheck200ResponseFromJSON,
     HealthCheck200ResponseToJSON,
+    LoadMarkets200ResponseFromJSON,
+    LoadMarkets200ResponseToJSON,
+    LoadMarketsRequestFromJSON,
+    LoadMarketsRequestToJSON,
+    SubmitOrderRequestFromJSON,
+    SubmitOrderRequestToJSON,
     WatchOrderBookRequestFromJSON,
     WatchOrderBookRequestToJSON,
-    WatchPricesRequestFromJSON,
-    WatchPricesRequestToJSON,
     WatchTradesRequestFromJSON,
     WatchTradesRequestToJSON,
-    WatchUserPositionsRequestFromJSON,
-    WatchUserPositionsRequestToJSON,
 } from '../models/index';
 
+export interface BuildOrderOperationRequest {
+    exchange: BuildOrderOperationExchangeEnum;
+    buildOrderRequest?: BuildOrderRequest;
+}
+
 export interface CancelOrderOperationRequest {
     exchange: CancelOrderOperationExchangeEnum;
     cancelOrderRequest?: CancelOrderRequest;
 }
 
-export interface CloseRequest {
-    exchange: CloseExchangeEnum;
-    watchUserPositionsRequest?: WatchUserPositionsRequest;
+export interface CloseOperationRequest {
+    exchange: CloseOperationExchangeEnum;
+    closeRequest?: CloseRequest;
 }
 
 export interface CreateOrderOperationRequest {
@@ -133,14 +177,24 @@ export interface CreateOrderOperationRequest {
     createOrderRequest?: CreateOrderRequest;
 }
 
-export interface FetchBalanceRequest {
-    exchange: FetchBalanceExchangeEnum;
-    fetchPositionsRequest?: FetchPositionsRequest;
+export interface FetchAllOrdersOperationRequest {
+    exchange: FetchAllOrdersOperationExchangeEnum;
+    fetchAllOrdersRequest?: FetchAllOrdersRequest;
 }
 
-export interface FetchEventRequest {
-    exchange: FetchEventExchangeEnum;
-    fetchEventsRequest?: FetchEventsRequest;
+export interface FetchBalanceOperationRequest {
+    exchange: FetchBalanceOperationExchangeEnum;
+    fetchBalanceRequest?: FetchBalanceRequest;
+}
+
+export interface FetchClosedOrdersOperationRequest {
+    exchange: FetchClosedOrdersOperationExchangeEnum;
+    fetchClosedOrdersRequest?: FetchClosedOrdersRequest;
+}
+
+export interface FetchEventOperationRequest {
+    exchange: FetchEventOperationExchangeEnum;
+    fetchEventRequest?: FetchEventRequest;
 }
 
 export interface FetchEventsOperationRequest {
@@ -158,6 +212,16 @@ export interface FetchMarketsOperationRequest {
     fetchMarketsRequest?: FetchMarketsRequest;
 }
 
+export interface FetchMarketsPaginatedOperationRequest {
+    exchange: FetchMarketsPaginatedOperationExchangeEnum;
+    fetchMarketsPaginatedRequest?: FetchMarketsPaginatedRequest;
+}
+
+export interface FetchMyTradesOperationRequest {
+    exchange: FetchMyTradesOperationExchangeEnum;
+    fetchMyTradesRequest?: FetchMyTradesRequest;
+}
+
 export interface FetchOHLCVOperationRequest {
     exchange: FetchOHLCVOperationExchangeEnum;
     fetchOHLCVRequest?: FetchOHLCVRequest;
@@ -168,9 +232,9 @@ export interface FetchOpenOrdersOperationRequest {
     fetchOpenOrdersRequest?: FetchOpenOrdersRequest;
 }
 
-export interface FetchOrderRequest {
-    exchange: FetchOrderExchangeEnum;
-    cancelOrderRequest?: CancelOrderRequest;
+export interface FetchOrderOperationRequest {
+    exchange: FetchOrderOperationExchangeEnum;
+    fetchOrderRequest?: FetchOrderRequest;
 }
 
 export interface FetchOrderBookOperationRequest {
@@ -203,9 +267,19 @@ export interface GetExecutionPriceOperationRequest {
     getExecutionPriceRequest?: GetExecutionPriceRequest;
 }
 
-export interface GetExecutionPriceDetailedRequest {
-    exchange: GetExecutionPriceDetailedExchangeEnum;
-    getExecutionPriceRequest?: GetExecutionPriceRequest;
+export interface GetExecutionPriceDetailedOperationRequest {
+    exchange: GetExecutionPriceDetailedOperationExchangeEnum;
+    getExecutionPriceDetailedRequest?: GetExecutionPriceDetailedRequest;
+}
+
+export interface LoadMarketsOperationRequest {
+    exchange: LoadMarketsOperationExchangeEnum;
+    loadMarketsRequest?: LoadMarketsRequest;
+}
+
+export interface SubmitOrderOperationRequest {
+    exchange: SubmitOrderOperationExchangeEnum;
+    submitOrderRequest?: SubmitOrderRequest;
 }
 
 export interface WatchOrderBookOperationRequest {
@@ -213,32 +287,60 @@ export interface WatchOrderBookOperationRequest {
     watchOrderBookRequest?: WatchOrderBookRequest;
 }
 
-export interface WatchPricesOperationRequest {
-    exchange: WatchPricesOperationExchangeEnum;
-    watchPricesRequest?: WatchPricesRequest;
-}
-
 export interface WatchTradesOperationRequest {
     exchange: WatchTradesOperationExchangeEnum;
     watchTradesRequest?: WatchTradesRequest;
 }
 
-export interface WatchUserPositionsOperationRequest {
-    exchange: WatchUserPositionsOperationExchangeEnum;
-    watchUserPositionsRequest?: WatchUserPositionsRequest;
-}
-
-export interface WatchUserTransactionsRequest {
-    exchange: WatchUserTransactionsExchangeEnum;
-    watchUserPositionsRequest?: WatchUserPositionsRequest;
-}
-
 /**
  * 
  */
 export class DefaultApi extends runtime.BaseAPI {
 
     /**
+     * Build an order payload without submitting it to the exchange. Returns the exchange-native signed order or request body for inspection, forwarding through a middleware layer, or deferred submission via submitOrder().
+     * Build Order
+     */
+    async buildOrderRaw(requestParameters: BuildOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BuildOrder200Response>> {
+        if (requestParameters['exchange'] == null) {
+            throw new runtime.RequiredError(
+                'exchange',
+                'Required parameter "exchange" was null or undefined when calling buildOrder().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/api/{exchange}/buildOrder`;
+        urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: BuildOrderRequestToJSON(requestParameters['buildOrderRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => BuildOrder200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Build an order payload without submitting it to the exchange. Returns the exchange-native signed order or request body for inspection, forwarding through a middleware layer, or deferred submission via submitOrder().
+     * Build Order
+     */
+    async buildOrder(requestParameters: BuildOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BuildOrder200Response> {
+        const response = await this.buildOrderRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Cancel an existing open order.
      * Cancel Order
      */
     async cancelOrderRaw(requestParameters: CancelOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateOrder200Response>> {
@@ -271,6 +373,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Cancel an existing open order.
      * Cancel Order
      */
     async cancelOrder(requestParameters: CancelOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateOrder200Response> {
@@ -279,10 +382,10 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Close all WebSocket connections and cleanup resources. Call this when you\'re done streaming to properly release connections. 
-     * Close WebSocket Connections
+     * Close all WebSocket connections and clean up resources. Call this when you\'re done streaming to properly release connections.
+     * Close
      */
-    async closeRaw(requestParameters: CloseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
+    async closeRaw(requestParameters: CloseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -305,22 +408,23 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: WatchUserPositionsRequestToJSON(requestParameters['watchUserPositionsRequest']),
+            body: CloseRequestToJSON(requestParameters['closeRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => BaseResponseFromJSON(jsonValue));
     }
 
     /**
-     * Close all WebSocket connections and cleanup resources. Call this when you\'re done streaming to properly release connections. 
-     * Close WebSocket Connections
+     * Close all WebSocket connections and clean up resources. Call this when you\'re done streaming to properly release connections.
+     * Close
      */
-    async close(requestParameters: CloseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
+    async close(requestParameters: CloseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
         const response = await this.closeRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
+     * Place a new order on the exchange.
      * Create Order
      */
     async createOrderRaw(requestParameters: CreateOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateOrder200Response>> {
@@ -353,6 +457,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Place a new order on the exchange.
      * Create Order
      */
     async createOrder(requestParameters: CreateOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateOrder200Response> {
@@ -361,9 +466,50 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch All Orders
+     */
+    async fetchAllOrdersRaw(requestParameters: FetchAllOrdersOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOpenOrders200Response>> {
+        if (requestParameters['exchange'] == null) {
+            throw new runtime.RequiredError(
+                'exchange',
+                'Required parameter "exchange" was null or undefined when calling fetchAllOrders().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/api/{exchange}/fetchAllOrders`;
+        urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: FetchAllOrdersRequestToJSON(requestParameters['fetchAllOrdersRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => FetchOpenOrders200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Fetch All Orders
+     */
+    async fetchAllOrders(requestParameters: FetchAllOrdersOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOpenOrders200Response> {
+        const response = await this.fetchAllOrdersRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Fetch account balances.
      * Fetch Balance
      */
-    async fetchBalanceRaw(requestParameters: FetchBalanceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchBalance200Response>> {
+    async fetchBalanceRaw(requestParameters: FetchBalanceOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchBalance200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -386,25 +532,66 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: FetchPositionsRequestToJSON(requestParameters['fetchPositionsRequest']),
+            body: FetchBalanceRequestToJSON(requestParameters['fetchBalanceRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => FetchBalance200ResponseFromJSON(jsonValue));
     }
 
     /**
+     * Fetch account balances.
      * Fetch Balance
      */
-    async fetchBalance(requestParameters: FetchBalanceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchBalance200Response> {
+    async fetchBalance(requestParameters: FetchBalanceOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchBalance200Response> {
         const response = await this.fetchBalanceRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Fetch a single event by lookup parameters. Returns the first matching event or a 404 error if no event is found. Convenience wrapper around fetchEvents. 
-     * Fetch Single Event
+     * Fetch Closed Orders
      */
-    async fetchEventRaw(requestParameters: FetchEventRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchEvent200Response>> {
+    async fetchClosedOrdersRaw(requestParameters: FetchClosedOrdersOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOpenOrders200Response>> {
+        if (requestParameters['exchange'] == null) {
+            throw new runtime.RequiredError(
+                'exchange',
+                'Required parameter "exchange" was null or undefined when calling fetchClosedOrders().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/api/{exchange}/fetchClosedOrders`;
+        urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: FetchClosedOrdersRequestToJSON(requestParameters['fetchClosedOrdersRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => FetchOpenOrders200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Fetch Closed Orders
+     */
+    async fetchClosedOrders(requestParameters: FetchClosedOrdersOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOpenOrders200Response> {
+        const response = await this.fetchClosedOrdersRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Fetch a single event by lookup parameters. Convenience wrapper around fetchEvents() that returns a single result or throws EventNotFound.
+     * Fetch Event
+     */
+    async fetchEventRaw(requestParameters: FetchEventOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchEvent200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -427,22 +614,23 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: FetchEventsRequestToJSON(requestParameters['fetchEventsRequest']),
+            body: FetchEventRequestToJSON(requestParameters['fetchEventRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => FetchEvent200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Fetch a single event by lookup parameters. Returns the first matching event or a 404 error if no event is found. Convenience wrapper around fetchEvents. 
-     * Fetch Single Event
+     * Fetch a single event by lookup parameters. Convenience wrapper around fetchEvents() that returns a single result or throws EventNotFound.
+     * Fetch Event
      */
-    async fetchEvent(requestParameters: FetchEventRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchEvent200Response> {
+    async fetchEvent(requestParameters: FetchEventOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchEvent200Response> {
         const response = await this.fetchEventRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
+     * Fetch events with optional keyword search. Events group related markets together (e.g., \"Who will be Fed Chair?\" contains multiple candidate markets).
      * Fetch Events
      */
     async fetchEventsRaw(requestParameters: FetchEventsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchEvents200Response>> {
@@ -475,6 +663,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch events with optional keyword search. Events group related markets together (e.g., \"Who will be Fed Chair?\" contains multiple candidate markets).
      * Fetch Events
      */
     async fetchEvents(requestParameters: FetchEventsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchEvents200Response> {
@@ -483,8 +672,8 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Fetch a single market by lookup parameters. Returns the first matching market or a 404 error if no market is found. Convenience wrapper around fetchMarkets. 
-     * Fetch Single Market
+     * Fetch a single market by lookup parameters. Convenience wrapper around fetchMarkets() that returns a single result or throws MarketNotFound.
+     * Fetch Market
      */
     async fetchMarketRaw(requestParameters: FetchMarketOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchMarket200Response>> {
         if (requestParameters['exchange'] == null) {
@@ -516,8 +705,8 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Fetch a single market by lookup parameters. Returns the first matching market or a 404 error if no market is found. Convenience wrapper around fetchMarkets. 
-     * Fetch Single Market
+     * Fetch a single market by lookup parameters. Convenience wrapper around fetchMarkets() that returns a single result or throws MarketNotFound.
+     * Fetch Market
      */
     async fetchMarket(requestParameters: FetchMarketOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchMarket200Response> {
         const response = await this.fetchMarketRaw(requestParameters, initOverrides);
@@ -525,6 +714,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch markets with optional filtering, search, or slug lookup. Always hits the exchange API — results reflect the live state at the time of the call.
      * Fetch Markets
      */
     async fetchMarketsRaw(requestParameters: FetchMarketsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchMarkets200Response>> {
@@ -557,6 +747,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch markets with optional filtering, search, or slug lookup. Always hits the exchange API — results reflect the live state at the time of the call.
      * Fetch Markets
      */
     async fetchMarkets(requestParameters: FetchMarketsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchMarkets200Response> {
@@ -565,7 +756,90 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Fetch OHLCV Candles
+     * Fetch markets with cursor-based pagination backed by a stable in-memory snapshot. On the first call (or when no cursor is supplied), fetches all markets once and caches them. Subsequent calls with a cursor returned from a previous call slice directly from the cached snapshot — no additional API calls are made. The snapshot is invalidated after `snapshotTTL` ms (configured via `ExchangeOptions` in the constructor). A request using a cursor from an expired snapshot throws `\'Cursor has expired\'`.
+     * Fetch Markets Paginated
+     */
+    async fetchMarketsPaginatedRaw(requestParameters: FetchMarketsPaginatedOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchMarketsPaginated200Response>> {
+        if (requestParameters['exchange'] == null) {
+            throw new runtime.RequiredError(
+                'exchange',
+                'Required parameter "exchange" was null or undefined when calling fetchMarketsPaginated().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/api/{exchange}/fetchMarketsPaginated`;
+        urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: FetchMarketsPaginatedRequestToJSON(requestParameters['fetchMarketsPaginatedRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => FetchMarketsPaginated200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Fetch markets with cursor-based pagination backed by a stable in-memory snapshot. On the first call (or when no cursor is supplied), fetches all markets once and caches them. Subsequent calls with a cursor returned from a previous call slice directly from the cached snapshot — no additional API calls are made. The snapshot is invalidated after `snapshotTTL` ms (configured via `ExchangeOptions` in the constructor). A request using a cursor from an expired snapshot throws `\'Cursor has expired\'`.
+     * Fetch Markets Paginated
+     */
+    async fetchMarketsPaginated(requestParameters: FetchMarketsPaginatedOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchMarketsPaginated200Response> {
+        const response = await this.fetchMarketsPaginatedRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Fetch My Trades
+     */
+    async fetchMyTradesRaw(requestParameters: FetchMyTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchMyTrades200Response>> {
+        if (requestParameters['exchange'] == null) {
+            throw new runtime.RequiredError(
+                'exchange',
+                'Required parameter "exchange" was null or undefined when calling fetchMyTrades().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/api/{exchange}/fetchMyTrades`;
+        urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: FetchMyTradesRequestToJSON(requestParameters['fetchMyTradesRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => FetchMyTrades200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Fetch My Trades
+     */
+    async fetchMyTrades(requestParameters: FetchMyTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchMyTrades200Response> {
+        const response = await this.fetchMyTradesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Fetch historical OHLCV (candlestick) price data for a specific market outcome.
+     * Fetch O H L C V
      */
     async fetchOHLCVRaw(requestParameters: FetchOHLCVOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOHLCV200Response>> {
         if (requestParameters['exchange'] == null) {
@@ -597,7 +871,8 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Fetch OHLCV Candles
+     * Fetch historical OHLCV (candlestick) price data for a specific market outcome.
+     * Fetch O H L C V
      */
     async fetchOHLCV(requestParameters: FetchOHLCVOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOHLCV200Response> {
         const response = await this.fetchOHLCVRaw(requestParameters, initOverrides);
@@ -605,6 +880,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch all open orders, optionally filtered by market.
      * Fetch Open Orders
      */
     async fetchOpenOrdersRaw(requestParameters: FetchOpenOrdersOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOpenOrders200Response>> {
@@ -637,6 +913,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch all open orders, optionally filtered by market.
      * Fetch Open Orders
      */
     async fetchOpenOrders(requestParameters: FetchOpenOrdersOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOpenOrders200Response> {
@@ -645,9 +922,10 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch a specific order by ID.
      * Fetch Order
      */
-    async fetchOrderRaw(requestParameters: FetchOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateOrder200Response>> {
+    async fetchOrderRaw(requestParameters: FetchOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateOrder200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -670,21 +948,23 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: CancelOrderRequestToJSON(requestParameters['cancelOrderRequest']),
+            body: FetchOrderRequestToJSON(requestParameters['fetchOrderRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => CreateOrder200ResponseFromJSON(jsonValue));
     }
 
     /**
+     * Fetch a specific order by ID.
      * Fetch Order
      */
-    async fetchOrder(requestParameters: FetchOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateOrder200Response> {
+    async fetchOrder(requestParameters: FetchOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateOrder200Response> {
         const response = await this.fetchOrderRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
+     * Fetch the current order book (bids/asks) for a specific outcome. Essential for calculating spread, depth, and execution prices.
      * Fetch Order Book
      */
     async fetchOrderBookRaw(requestParameters: FetchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOrderBook200Response>> {
@@ -717,6 +997,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch the current order book (bids/asks) for a specific outcome. Essential for calculating spread, depth, and execution prices.
      * Fetch Order Book
      */
     async fetchOrderBook(requestParameters: FetchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOrderBook200Response> {
@@ -725,6 +1006,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch current user positions across all markets.
      * Fetch Positions
      */
     async fetchPositionsRaw(requestParameters: FetchPositionsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchPositions200Response>> {
@@ -757,6 +1039,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch current user positions across all markets.
      * Fetch Positions
      */
     async fetchPositions(requestParameters: FetchPositionsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchPositions200Response> {
@@ -765,6 +1048,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch raw trade history for a specific outcome.
      * Fetch Trades
      */
     async fetchTradesRaw(requestParameters: FetchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchTrades200Response>> {
@@ -797,6 +1081,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Fetch raw trade history for a specific outcome.
      * Fetch Trades
      */
     async fetchTrades(requestParameters: FetchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchTrades200Response> {
@@ -805,7 +1090,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Filter a list of events by criteria. Can filter by string query, structured criteria object, or custom filter function. 
+     * Filter a list of events by criteria. Can filter by string query, structured criteria object, or custom filter function.
      * Filter Events
      */
     async filterEventsRaw(requestParameters: FilterEventsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchEvents200Response>> {
@@ -838,7 +1123,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Filter a list of events by criteria. Can filter by string query, structured criteria object, or custom filter function. 
+     * Filter a list of events by criteria. Can filter by string query, structured criteria object, or custom filter function.
      * Filter Events
      */
     async filterEvents(requestParameters: FilterEventsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchEvents200Response> {
@@ -847,7 +1132,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Filter a list of markets by criteria. Can filter by string query, structured criteria object, or custom filter function. 
+     * Filter a list of markets by criteria. Can filter by string query, structured criteria object, or custom filter function.
      * Filter Markets
      */
     async filterMarketsRaw(requestParameters: FilterMarketsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchMarkets200Response>> {
@@ -880,7 +1165,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Filter a list of markets by criteria. Can filter by string query, structured criteria object, or custom filter function. 
+     * Filter a list of markets by criteria. Can filter by string query, structured criteria object, or custom filter function.
      * Filter Markets
      */
     async filterMarkets(requestParameters: FilterMarketsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchMarkets200Response> {
@@ -889,6 +1174,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Calculate the volume-weighted average execution price for a given order size. Returns 0 if the order cannot be fully filled.
      * Get Execution Price
      */
     async getExecutionPriceRaw(requestParameters: GetExecutionPriceOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetExecutionPrice200Response>> {
@@ -921,6 +1207,7 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
+     * Calculate the volume-weighted average execution price for a given order size. Returns 0 if the order cannot be fully filled.
      * Get Execution Price
      */
     async getExecutionPrice(requestParameters: GetExecutionPriceOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetExecutionPrice200Response> {
@@ -929,9 +1216,10 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Get Detailed Execution Price
+     * Calculate detailed execution price information including partial fill data.
+     * Get Execution Price Detailed
      */
-    async getExecutionPriceDetailedRaw(requestParameters: GetExecutionPriceDetailedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetExecutionPriceDetailed200Response>> {
+    async getExecutionPriceDetailedRaw(requestParameters: GetExecutionPriceDetailedOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetExecutionPriceDetailed200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
@@ -954,16 +1242,17 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: GetExecutionPriceRequestToJSON(requestParameters['getExecutionPriceRequest']),
+            body: GetExecutionPriceDetailedRequestToJSON(requestParameters['getExecutionPriceDetailedRequest']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => GetExecutionPriceDetailed200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get Detailed Execution Price
+     * Calculate detailed execution price information including partial fill data.
+     * Get Execution Price Detailed
      */
-    async getExecutionPriceDetailed(requestParameters: GetExecutionPriceDetailedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetExecutionPriceDetailed200Response> {
+    async getExecutionPriceDetailed(requestParameters: GetExecutionPriceDetailedOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetExecutionPriceDetailed200Response> {
         const response = await this.getExecutionPriceDetailedRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -998,14 +1287,14 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Subscribe to real-time order book updates 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 (WebSocket Stream)
+     * Load and cache all markets from the exchange into `this.markets` and `this.marketsBySlug`. Subsequent calls return the cached result without hitting the API again. This is the correct way to paginate or iterate over markets without drift. Because `fetchMarkets()` always hits the API, repeated calls with different `offset` values may return inconsistent results if the exchange reorders or adds markets between requests. Use `loadMarkets()` once to get a stable snapshot, then paginate over `Object.values(exchange.markets)` locally.
+     * Load Markets
      */
-    async watchOrderBookRaw(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOrderBook200Response>> {
+    async loadMarketsRaw(requestParameters: LoadMarketsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LoadMarkets200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
-                'Required parameter "exchange" was null or undefined when calling watchOrderBook().'
+                'Required parameter "exchange" was null or undefined when calling loadMarkets().'
             );
         }
 
@@ -1016,7 +1305,7 @@ export class DefaultApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
 
-        let urlPath = `/api/{exchange}/watchOrderBook`;
+        let urlPath = `/api/{exchange}/loadMarkets`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
 
         const response = await this.request({
@@ -1024,29 +1313,30 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: WatchOrderBookRequestToJSON(requestParameters['watchOrderBookRequest']),
+            body: LoadMarketsRequestToJSON(requestParameters['loadMarketsRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => FetchOrderBook200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => LoadMarkets200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Subscribe to real-time order book updates 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 (WebSocket Stream)
+     * Load and cache all markets from the exchange into `this.markets` and `this.marketsBySlug`. Subsequent calls return the cached result without hitting the API again. This is the correct way to paginate or iterate over markets without drift. Because `fetchMarkets()` always hits the API, repeated calls with different `offset` values may return inconsistent results if the exchange reorders or adds markets between requests. Use `loadMarkets()` once to get a stable snapshot, then paginate over `Object.values(exchange.markets)` locally.
+     * Load Markets
      */
-    async watchOrderBook(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOrderBook200Response> {
-        const response = await this.watchOrderBookRaw(requestParameters, initOverrides);
+    async loadMarkets(requestParameters: LoadMarketsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LoadMarkets200Response> {
+        const response = await this.loadMarketsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Watch Prices (WebSocket Stream)
+     * Submit a pre-built order returned by buildOrder().
+     * Submit Order
      */
-    async watchPricesRaw(requestParameters: WatchPricesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
+    async submitOrderRaw(requestParameters: SubmitOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateOrder200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
-                'Required parameter "exchange" was null or undefined when calling watchPrices().'
+                'Required parameter "exchange" was null or undefined when calling submitOrder().'
             );
         }
 
@@ -1057,7 +1347,7 @@ export class DefaultApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
 
-        let urlPath = `/api/{exchange}/watchPrices`;
+        let urlPath = `/api/{exchange}/submitOrder`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
 
         const response = await this.request({
@@ -1065,70 +1355,30 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: WatchPricesRequestToJSON(requestParameters['watchPricesRequest']),
+            body: SubmitOrderRequestToJSON(requestParameters['submitOrderRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => BaseResponseFromJSON(jsonValue));
-    }
-
-    /**
-     * Watch Prices (WebSocket Stream)
-     */
-    async watchPrices(requestParameters: WatchPricesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
-        const response = await this.watchPricesRaw(requestParameters, initOverrides);
-        return await response.value();
-    }
-
-    /**
-     * Subscribe to real-time trade updates 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 (WebSocket Stream)
-     */
-    async watchTradesRaw(requestParameters: WatchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchTrades200Response>> {
-        if (requestParameters['exchange'] == null) {
-            throw new runtime.RequiredError(
-                'exchange',
-                'Required parameter "exchange" was null or undefined when calling watchTrades().'
-            );
-        }
-
-        const queryParameters: any = {};
-
-        const headerParameters: runtime.HTTPHeaders = {};
-
-        headerParameters['Content-Type'] = 'application/json';
-
-
-        let urlPath = `/api/{exchange}/watchTrades`;
-        urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
-
-        const response = await this.request({
-            path: urlPath,
-            method: 'POST',
-            headers: headerParameters,
-            query: queryParameters,
-            body: WatchTradesRequestToJSON(requestParameters['watchTradesRequest']),
-        }, initOverrides);
-
-        return new runtime.JSONApiResponse(response, (jsonValue) => FetchTrades200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CreateOrder200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Subscribe to real-time trade updates 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 (WebSocket Stream)
+     * Submit a pre-built order returned by buildOrder().
+     * Submit Order
      */
-    async watchTrades(requestParameters: WatchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchTrades200Response> {
-        const response = await this.watchTradesRaw(requestParameters, initOverrides);
+    async submitOrder(requestParameters: SubmitOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateOrder200Response> {
+        const response = await this.submitOrderRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Watch User Positions (WebSocket Stream)
+     * 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
      */
-    async watchUserPositionsRaw(requestParameters: WatchUserPositionsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
+    async watchOrderBookRaw(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOrderBook200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
-                'Required parameter "exchange" was null or undefined when calling watchUserPositions().'
+                'Required parameter "exchange" was null or undefined when calling watchOrderBook().'
             );
         }
 
@@ -1139,7 +1389,7 @@ export class DefaultApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
 
-        let urlPath = `/api/{exchange}/watchUserPositions`;
+        let urlPath = `/api/{exchange}/watchOrderBook`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
 
         const response = await this.request({
@@ -1147,28 +1397,30 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: WatchUserPositionsRequestToJSON(requestParameters['watchUserPositionsRequest']),
+            body: WatchOrderBookRequestToJSON(requestParameters['watchOrderBookRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => BaseResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => FetchOrderBook200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Watch User Positions (WebSocket Stream)
+     * 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
      */
-    async watchUserPositions(requestParameters: WatchUserPositionsOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
-        const response = await this.watchUserPositionsRaw(requestParameters, initOverrides);
+    async watchOrderBook(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOrderBook200Response> {
+        const response = await this.watchOrderBookRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Watch User Transactions (WebSocket Stream)
+     * 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
      */
-    async watchUserTransactionsRaw(requestParameters: WatchUserTransactionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>> {
+    async watchTradesRaw(requestParameters: WatchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchTrades200Response>> {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError(
                 'exchange',
-                'Required parameter "exchange" was null or undefined when calling watchUserTransactions().'
+                'Required parameter "exchange" was null or undefined when calling watchTrades().'
             );
         }
 
@@ -1179,7 +1431,7 @@ export class DefaultApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
 
-        let urlPath = `/api/{exchange}/watchUserTransactions`;
+        let urlPath = `/api/{exchange}/watchTrades`;
         urlPath = urlPath.replace(`{${"exchange"}}`, encodeURIComponent(String(requestParameters['exchange'])));
 
         const response = await this.request({
@@ -1187,22 +1439,35 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: WatchUserPositionsRequestToJSON(requestParameters['watchUserPositionsRequest']),
+            body: WatchTradesRequestToJSON(requestParameters['watchTradesRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => BaseResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => FetchTrades200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Watch User Transactions (WebSocket Stream)
+     * 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
      */
-    async watchUserTransactions(requestParameters: WatchUserTransactionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse> {
-        const response = await this.watchUserTransactionsRaw(requestParameters, initOverrides);
+    async watchTrades(requestParameters: WatchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchTrades200Response> {
+        const response = await this.watchTradesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
 }
 
+/**
+ * @export
+ */
+export const BuildOrderOperationExchangeEnum = {
+    Polymarket: 'polymarket',
+    Kalshi: 'kalshi',
+    Limitless: 'limitless',
+    Probable: 'probable',
+    Baozi: 'baozi',
+    Myriad: 'myriad'
+} as const;
+export type BuildOrderOperationExchangeEnum = typeof BuildOrderOperationExchangeEnum[keyof typeof BuildOrderOperationExchangeEnum];
 /**
  * @export
  */
@@ -1218,7 +1483,7 @@ export type CancelOrderOperationExchangeEnum = typeof CancelOrderOperationExchan
 /**
  * @export
  */
-export const CloseExchangeEnum = {
+export const CloseOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1226,7 +1491,7 @@ export const CloseExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type CloseExchangeEnum = typeof CloseExchangeEnum[keyof typeof CloseExchangeEnum];
+export type CloseOperationExchangeEnum = typeof CloseOperationExchangeEnum[keyof typeof CloseOperationExchangeEnum];
 /**
  * @export
  */
@@ -1242,7 +1507,19 @@ export type CreateOrderOperationExchangeEnum = typeof CreateOrderOperationExchan
 /**
  * @export
  */
-export const FetchBalanceExchangeEnum = {
+export const FetchAllOrdersOperationExchangeEnum = {
+    Polymarket: 'polymarket',
+    Kalshi: 'kalshi',
+    Limitless: 'limitless',
+    Probable: 'probable',
+    Baozi: 'baozi',
+    Myriad: 'myriad'
+} as const;
+export type FetchAllOrdersOperationExchangeEnum = typeof FetchAllOrdersOperationExchangeEnum[keyof typeof FetchAllOrdersOperationExchangeEnum];
+/**
+ * @export
+ */
+export const FetchBalanceOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1250,11 +1527,11 @@ export const FetchBalanceExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type FetchBalanceExchangeEnum = typeof FetchBalanceExchangeEnum[keyof typeof FetchBalanceExchangeEnum];
+export type FetchBalanceOperationExchangeEnum = typeof FetchBalanceOperationExchangeEnum[keyof typeof FetchBalanceOperationExchangeEnum];
 /**
  * @export
  */
-export const FetchEventExchangeEnum = {
+export const FetchClosedOrdersOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1262,7 +1539,19 @@ export const FetchEventExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type FetchEventExchangeEnum = typeof FetchEventExchangeEnum[keyof typeof FetchEventExchangeEnum];
+export type FetchClosedOrdersOperationExchangeEnum = typeof FetchClosedOrdersOperationExchangeEnum[keyof typeof FetchClosedOrdersOperationExchangeEnum];
+/**
+ * @export
+ */
+export const FetchEventOperationExchangeEnum = {
+    Polymarket: 'polymarket',
+    Kalshi: 'kalshi',
+    Limitless: 'limitless',
+    Probable: 'probable',
+    Baozi: 'baozi',
+    Myriad: 'myriad'
+} as const;
+export type FetchEventOperationExchangeEnum = typeof FetchEventOperationExchangeEnum[keyof typeof FetchEventOperationExchangeEnum];
 /**
  * @export
  */
@@ -1299,6 +1588,30 @@ export const FetchMarketsOperationExchangeEnum = {
     Myriad: 'myriad'
 } as const;
 export type FetchMarketsOperationExchangeEnum = typeof FetchMarketsOperationExchangeEnum[keyof typeof FetchMarketsOperationExchangeEnum];
+/**
+ * @export
+ */
+export const FetchMarketsPaginatedOperationExchangeEnum = {
+    Polymarket: 'polymarket',
+    Kalshi: 'kalshi',
+    Limitless: 'limitless',
+    Probable: 'probable',
+    Baozi: 'baozi',
+    Myriad: 'myriad'
+} as const;
+export type FetchMarketsPaginatedOperationExchangeEnum = typeof FetchMarketsPaginatedOperationExchangeEnum[keyof typeof FetchMarketsPaginatedOperationExchangeEnum];
+/**
+ * @export
+ */
+export const FetchMyTradesOperationExchangeEnum = {
+    Polymarket: 'polymarket',
+    Kalshi: 'kalshi',
+    Limitless: 'limitless',
+    Probable: 'probable',
+    Baozi: 'baozi',
+    Myriad: 'myriad'
+} as const;
+export type FetchMyTradesOperationExchangeEnum = typeof FetchMyTradesOperationExchangeEnum[keyof typeof FetchMyTradesOperationExchangeEnum];
 /**
  * @export
  */
@@ -1326,7 +1639,7 @@ export type FetchOpenOrdersOperationExchangeEnum = typeof FetchOpenOrdersOperati
 /**
  * @export
  */
-export const FetchOrderExchangeEnum = {
+export const FetchOrderOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1334,7 +1647,7 @@ export const FetchOrderExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type FetchOrderExchangeEnum = typeof FetchOrderExchangeEnum[keyof typeof FetchOrderExchangeEnum];
+export type FetchOrderOperationExchangeEnum = typeof FetchOrderOperationExchangeEnum[keyof typeof FetchOrderOperationExchangeEnum];
 /**
  * @export
  */
@@ -1410,7 +1723,7 @@ export type GetExecutionPriceOperationExchangeEnum = typeof GetExecutionPriceOpe
 /**
  * @export
  */
-export const GetExecutionPriceDetailedExchangeEnum = {
+export const GetExecutionPriceDetailedOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1418,11 +1731,11 @@ export const GetExecutionPriceDetailedExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type GetExecutionPriceDetailedExchangeEnum = typeof GetExecutionPriceDetailedExchangeEnum[keyof typeof GetExecutionPriceDetailedExchangeEnum];
+export type GetExecutionPriceDetailedOperationExchangeEnum = typeof GetExecutionPriceDetailedOperationExchangeEnum[keyof typeof GetExecutionPriceDetailedOperationExchangeEnum];
 /**
  * @export
  */
-export const WatchOrderBookOperationExchangeEnum = {
+export const LoadMarketsOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1430,11 +1743,11 @@ export const WatchOrderBookOperationExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type WatchOrderBookOperationExchangeEnum = typeof WatchOrderBookOperationExchangeEnum[keyof typeof WatchOrderBookOperationExchangeEnum];
+export type LoadMarketsOperationExchangeEnum = typeof LoadMarketsOperationExchangeEnum[keyof typeof LoadMarketsOperationExchangeEnum];
 /**
  * @export
  */
-export const WatchPricesOperationExchangeEnum = {
+export const SubmitOrderOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1442,23 +1755,11 @@ export const WatchPricesOperationExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type WatchPricesOperationExchangeEnum = typeof WatchPricesOperationExchangeEnum[keyof typeof WatchPricesOperationExchangeEnum];
+export type SubmitOrderOperationExchangeEnum = typeof SubmitOrderOperationExchangeEnum[keyof typeof SubmitOrderOperationExchangeEnum];
 /**
  * @export
  */
-export const WatchTradesOperationExchangeEnum = {
-    Polymarket: 'polymarket',
-    Kalshi: 'kalshi',
-    Limitless: 'limitless',
-    Probable: 'probable',
-    Baozi: 'baozi',
-    Myriad: 'myriad'
-} as const;
-export type WatchTradesOperationExchangeEnum = typeof WatchTradesOperationExchangeEnum[keyof typeof WatchTradesOperationExchangeEnum];
-/**
- * @export
- */
-export const WatchUserPositionsOperationExchangeEnum = {
+export const WatchOrderBookOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1466,11 +1767,11 @@ export const WatchUserPositionsOperationExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type WatchUserPositionsOperationExchangeEnum = typeof WatchUserPositionsOperationExchangeEnum[keyof typeof WatchUserPositionsOperationExchangeEnum];
+export type WatchOrderBookOperationExchangeEnum = typeof WatchOrderBookOperationExchangeEnum[keyof typeof WatchOrderBookOperationExchangeEnum];
 /**
  * @export
  */
-export const WatchUserTransactionsExchangeEnum = {
+export const WatchTradesOperationExchangeEnum = {
     Polymarket: 'polymarket',
     Kalshi: 'kalshi',
     Limitless: 'limitless',
@@ -1478,4 +1779,4 @@ export const WatchUserTransactionsExchangeEnum = {
     Baozi: 'baozi',
     Myriad: 'myriad'
 } as const;
-export type WatchUserTransactionsExchangeEnum = typeof WatchUserTransactionsExchangeEnum[keyof typeof WatchUserTransactionsExchangeEnum];
+export type WatchTradesOperationExchangeEnum = typeof WatchTradesOperationExchangeEnum[keyof typeof WatchTradesOperationExchangeEnum];