pmxtjs 2.19.6 → 2.20.1

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

@@ -4,8 +4,8 @@
  * This module provides clean, TypeScript-friendly wrappers around the auto-generated
  * OpenAPI client, matching the Python API exactly.
  */
-import { DefaultApi, Configuration, ExchangeCredentials } from "../generated/src/index.js";
-import { UnifiedMarket, PriceCandle, OrderBook, Trade, UserTrade, Order, Position, Balance, UnifiedEvent, ExecutionPriceResult, PaginatedMarketsResult, MarketFilterCriteria, MarketFilterFunction, EventFilterCriteria, EventFilterFunction } from "./models.js";
+import { Configuration, DefaultApi, ExchangeCredentials } from "../generated/src/index.js";
+import { Balance, BuiltOrder, CreateOrderParams, EventFilterCriteria, EventFilterFunction, ExecutionPriceResult, MarketFilterCriteria, MarketFilterFunction, MarketOutcome, Order, OrderBook, PaginatedMarketsResult, Position, PriceCandle, SubscribedAddressSnapshot, SubscriptionOption, Trade, UnifiedEvent, UnifiedMarket, UserTrade } from "./models.js";
 import { ServerManager } from "./server-manager.js";
 /**
  * Base exchange client options.
@@ -68,15 +68,14 @@ export declare abstract class Exchange {
     fetchMarket(params?: any): Promise<UnifiedMarket>;
     fetchEvent(params?: any): Promise<UnifiedEvent>;
     fetchOrderBook(id: string): Promise<OrderBook>;
-    submitOrder(built: any): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     fetchMyTrades(params?: any): Promise<UserTrade[]>;
     fetchClosedOrders(params?: any): Promise<Order[]>;
     fetchAllOrders(params?: any): Promise<Order[]>;
-    fetchPositions(): Promise<Position[]>;
-    fetchBalance(): Promise<Balance[]>;
+    fetchPositions(address?: string): Promise<Position[]>;
+    fetchBalance(address?: string): Promise<Balance[]>;
     close(): Promise<void>;
     /**
      * Get historical price candles.
@@ -134,6 +133,7 @@ export declare abstract class Exchange {
      * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
      * @param outcomeId - Outcome ID to watch
+     * @param address - Public wallet to be watched
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Next trade update(s)
@@ -149,7 +149,95 @@ export declare abstract class Exchange {
      * }
      * ```
      */
-    watchTrades(outcomeId: string, since?: number, limit?: number): Promise<Trade[]>;
+    watchTrades(outcomeId: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
+    /**
+     * Watch real-time updates of a public wallet via WebSocket.
+     *
+     * Returns a promise that resolves with the next update(s).
+     * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     *
+     * @param address - Public wallet to be watched
+     * @param types - Subscription options including 'trades', 'positions', and 'balances'
+     * @returns Next update(s)
+     *
+     * @example
+     * ```typescript
+     * // Stream updates of a public wallet address
+     * while (true) {
+     *   const snapshots = await exchange.watchAddress(address, types);
+     *   for (const snapshot of snapshots) {
+     *     console.log(`Trade: ${snapshot.trades}`);
+     *   }
+     * }
+     * ```
+     */
+    watchAddress(address: string, types?: SubscriptionOption[]): Promise<SubscribedAddressSnapshot>;
+    /**
+     * Stop watching a previously registered wallet address and release its resource updates.
+     *
+     * @param address - Public wallet to be watched
+     * @returns
+     */
+    unwatchAddress(address: string): Promise<Trade[]>;
+    /**
+     * Build an order payload without submitting it to the exchange.
+     * Returns the exchange-native signed order or transaction payload for
+     * inspection, forwarding through a middleware layer, or deferred
+     * submission via {@link submitOrder}.
+     *
+     * You can specify the market either with explicit marketId/outcomeId,
+     * or by passing an outcome object directly (e.g., market.yes).
+     *
+     * @param params - Order parameters (same as createOrder)
+     * @returns A BuiltOrder containing the exchange-native payload
+     *
+     * @example
+     * ```typescript
+     * // Build, inspect, then submit:
+     * const built = await exchange.buildOrder({
+     *   marketId: "663583",
+     *   outcomeId: "10991849...",
+     *   side: "buy",
+     *   type: "limit",
+     *   amount: 10,
+     *   price: 0.55
+     * });
+     *
+     * console.log(built.signedOrder); // inspect before submitting
+     * const order = await exchange.submitOrder(built);
+     *
+     * // Using outcome shorthand:
+     * const built2 = await exchange.buildOrder({
+     *   outcome: market.yes,
+     *   side: "buy",
+     *   type: "market",
+     *   amount: 10
+     * });
+     * ```
+     */
+    buildOrder(params: CreateOrderParams & {
+        outcome?: MarketOutcome;
+    }): Promise<BuiltOrder>;
+    /**
+     * Submit a pre-built order returned by {@link buildOrder}.
+     *
+     * @param built - The BuiltOrder payload from buildOrder()
+     * @returns The submitted order
+     *
+     * @example
+     * ```typescript
+     * const built = await exchange.buildOrder({
+     *   outcome: market.yes,
+     *   side: "buy",
+     *   type: "limit",
+     *   amount: 10,
+     *   price: 0.55
+     * });
+     * const order = await exchange.submitOrder(built);
+     * console.log(order.id, order.status);
+     * ```
+     */
+    submitOrder(built: BuiltOrder): Promise<Order>;
     /**
      * Create a new order.
      *

package/dist/esm/pmxt/client.js

@@ -4,9 +4,10 @@
  * This module provides clean, TypeScript-friendly wrappers around the auto-generated
  * OpenAPI client, matching the Python API exactly.
  */
-import { DefaultApi, Configuration, } from "../generated/src/index.js";
+import { Configuration, DefaultApi, } from "../generated/src/index.js";
 import { MarketList, } from "./models.js";
 import { ServerManager } from "./server-manager.js";
+import { buildArgsWithOptionalOptions } from "./args.js";
 // Converter functions
 function convertMarket(raw) {
     const outcomes = (raw.outcomes || []).map((o) => ({
@@ -143,6 +144,19 @@ function convertEvent(raw) {
     };
     return event;
 }
+function convertSubscriptionSnapshot(raw) {
+    const trades = (raw.trades ?? []).map(convertTrade);
+    const balances = (raw.balances ?? []).map(convertBalance);
+    const positions = (raw.positions ?? []).map(convertPosition);
+    const snapShot = {
+        address: raw.address,
+        trades,
+        balances,
+        positions,
+        timestamp: raw.timestamp,
+    };
+    return snapShot;
+}
 /**
  * Base class for prediction market exchanges.
  *
@@ -295,9 +309,7 @@ export class Exchange {
     async fetchMarkets(params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
+            const args = buildArgsWithOptionalOptions(params);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarkets`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -318,9 +330,7 @@ export class Exchange {
     async fetchMarketsPaginated(params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
+            const args = buildArgsWithOptionalOptions(params);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarketsPaginated`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -345,9 +355,7 @@ export class Exchange {
     async fetchEvents(params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
+            const args = buildArgsWithOptionalOptions(params);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchEvents`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -368,9 +376,7 @@ export class Exchange {
     async fetchMarket(params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
+            const args = buildArgsWithOptionalOptions(params);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMarket`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -391,9 +397,7 @@ export class Exchange {
     async fetchEvent(params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
+            const args = buildArgsWithOptionalOptions(params);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchEvent`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -433,28 +437,6 @@ export class Exchange {
             throw new Error(`Failed to fetchOrderBook: ${error}`);
         }
     }
-    async submitOrder(built) {
-        await this.initPromise;
-        try {
-            const args = [];
-            args.push(built);
-            const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/submitOrder`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
-                body: JSON.stringify({ args, credentials: this.getCredentials() }),
-            });
-            if (!response.ok) {
-                const error = await response.json().catch(() => ({}));
-                throw new Error(error.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            const data = this.handleResponse(json);
-            return convertOrder(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to submitOrder: ${error}`);
-        }
-    }
     async cancelOrder(orderId) {
         await this.initPromise;
         try {
@@ -502,9 +484,7 @@ export class Exchange {
     async fetchOpenOrders(marketId) {
         await this.initPromise;
         try {
-            const args = [];
-            if (marketId !== undefined)
-                args.push(marketId);
+            const args = buildArgsWithOptionalOptions(marketId);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchOpenOrders`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -525,9 +505,7 @@ export class Exchange {
     async fetchMyTrades(params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
+            const args = buildArgsWithOptionalOptions(params);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchMyTrades`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -548,9 +526,7 @@ export class Exchange {
     async fetchClosedOrders(params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
+            const args = buildArgsWithOptionalOptions(params);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchClosedOrders`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -571,9 +547,7 @@ export class Exchange {
     async fetchAllOrders(params) {
         await this.initPromise;
         try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
+            const args = buildArgsWithOptionalOptions(params);
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchAllOrders`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -591,10 +565,10 @@ export class Exchange {
             throw new Error(`Failed to fetchAllOrders: ${error}`);
         }
     }
-    async fetchPositions() {
+    async fetchPositions(address) {
         await this.initPromise;
         try {
-            const args = [];
+            const args = address ? [address] : [];
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchPositions`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -612,10 +586,10 @@ export class Exchange {
             throw new Error(`Failed to fetchPositions: ${error}`);
         }
     }
-    async fetchBalance() {
+    async fetchBalance(address) {
         await this.initPromise;
         try {
-            const args = [];
+            const args = address ? [address] : [];
             const response = await fetch(`${this.config.basePath}/api/${this.exchangeName}/fetchBalance`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -780,6 +754,7 @@ export class Exchange {
      * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
      * @param outcomeId - Outcome ID to watch
+     * @param address - Public wallet to be watched
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Next trade update(s)
@@ -795,10 +770,13 @@ export class Exchange {
      * }
      * ```
      */
-    async watchTrades(outcomeId, since, limit) {
+    async watchTrades(outcomeId, address, since, limit) {
         await this.initPromise;
         try {
             const args = [outcomeId];
+            if (address !== undefined) {
+                args.push(address);
+            }
             if (since !== undefined) {
                 args.push(since);
             }
@@ -820,7 +798,191 @@ export class Exchange {
             throw new Error(`Failed to watch trades: ${error}`);
         }
     }
+    /**
+     * Watch real-time updates of a public wallet via WebSocket.
+     *
+     * Returns a promise that resolves with the next update(s).
+     * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     *
+     * @param address - Public wallet to be watched
+     * @param types - Subscription options including 'trades', 'positions', and 'balances'
+     * @returns Next update(s)
+     *
+     * @example
+     * ```typescript
+     * // Stream updates of a public wallet address
+     * while (true) {
+     *   const snapshots = await exchange.watchAddress(address, types);
+     *   for (const snapshot of snapshots) {
+     *     console.log(`Trade: ${snapshot.trades}`);
+     *   }
+     * }
+     * ```
+     */
+    async watchAddress(address, types) {
+        await this.initPromise;
+        try {
+            const args = [address];
+            if (types !== undefined) {
+                args.push(types);
+            }
+            const requestBody = {
+                args,
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.watchAddress({
+                exchange: this.exchangeName,
+                watchAddressRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return convertSubscriptionSnapshot(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to watch address: ${error}`);
+        }
+    }
+    /**
+     * Stop watching a previously registered wallet address and release its resource updates.
+     *
+     * @param address - Public wallet to be watched
+     * @returns
+     */
+    async unwatchAddress(address) {
+        await this.initPromise;
+        try {
+            const args = [address];
+            const requestBody = {
+                args,
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.unwatchAddress({
+                exchange: this.exchangeName,
+                unwatchAddressRequest: requestBody,
+            });
+            return this.handleResponse(response);
+        }
+        catch (error) {
+            throw new Error(`Failed to unwatch address: ${error}`);
+        }
+    }
     // Trading Methods (require authentication)
+    /**
+     * Build an order payload without submitting it to the exchange.
+     * Returns the exchange-native signed order or transaction payload for
+     * inspection, forwarding through a middleware layer, or deferred
+     * submission via {@link submitOrder}.
+     *
+     * You can specify the market either with explicit marketId/outcomeId,
+     * or by passing an outcome object directly (e.g., market.yes).
+     *
+     * @param params - Order parameters (same as createOrder)
+     * @returns A BuiltOrder containing the exchange-native payload
+     *
+     * @example
+     * ```typescript
+     * // Build, inspect, then submit:
+     * const built = await exchange.buildOrder({
+     *   marketId: "663583",
+     *   outcomeId: "10991849...",
+     *   side: "buy",
+     *   type: "limit",
+     *   amount: 10,
+     *   price: 0.55
+     * });
+     *
+     * console.log(built.signedOrder); // inspect before submitting
+     * const order = await exchange.submitOrder(built);
+     *
+     * // Using outcome shorthand:
+     * const built2 = await exchange.buildOrder({
+     *   outcome: market.yes,
+     *   side: "buy",
+     *   type: "market",
+     *   amount: 10
+     * });
+     * ```
+     */
+    async buildOrder(params) {
+        await this.initPromise;
+        try {
+            let marketId = params.marketId;
+            let outcomeId = params.outcomeId;
+            if (params.outcome) {
+                if (marketId !== undefined || outcomeId !== undefined) {
+                    throw new Error("Cannot specify both 'outcome' and 'marketId'/'outcomeId'. Use one or the other.");
+                }
+                const outcome = params.outcome;
+                if (!outcome.marketId) {
+                    throw new Error("outcome.marketId is not set. Ensure the outcome comes from a fetched market.");
+                }
+                marketId = outcome.marketId;
+                outcomeId = outcome.outcomeId;
+            }
+            const paramsDict = {
+                marketId,
+                outcomeId,
+                side: params.side,
+                type: params.type,
+                amount: params.amount,
+            };
+            if (params.price !== undefined) {
+                paramsDict.price = params.price;
+            }
+            if (params.fee !== undefined) {
+                paramsDict.fee = params.fee;
+            }
+            const requestBody = {
+                args: [paramsDict],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.buildOrder({
+                exchange: this.exchangeName,
+                buildOrderRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return data;
+        }
+        catch (error) {
+            throw new Error(`Failed to build order: ${error}`);
+        }
+    }
+    /**
+     * Submit a pre-built order returned by {@link buildOrder}.
+     *
+     * @param built - The BuiltOrder payload from buildOrder()
+     * @returns The submitted order
+     *
+     * @example
+     * ```typescript
+     * const built = await exchange.buildOrder({
+     *   outcome: market.yes,
+     *   side: "buy",
+     *   type: "limit",
+     *   amount: 10,
+     *   price: 0.55
+     * });
+     * const order = await exchange.submitOrder(built);
+     * console.log(order.id, order.status);
+     * ```
+     */
+    async submitOrder(built) {
+        await this.initPromise;
+        try {
+            const requestBody = {
+                args: [built],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.submitOrder({
+                exchange: this.exchangeName,
+                submitOrderRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return convertOrder(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to submit order: ${error}`);
+        }
+    }
     /**
      * Create a new order.
      *

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

@@ -273,6 +273,26 @@ export interface CreateOrderParams {
     /** Optional fee rate (e.g., 1000 for 0.1%) */
     fee?: number;
 }
+/**
+ * An order payload built but not yet submitted to the exchange.
+ */
+export interface BuiltOrder {
+    /** The exchange name this order was built for. */
+    exchange: string;
+    /** The original params used to build this order. */
+    params: CreateOrderParams;
+    /** For CLOB exchanges (Polymarket): the EIP-712 signed order. */
+    signedOrder?: Record<string, unknown>;
+    /** For on-chain AMM exchanges: the EVM transaction payload. */
+    tx?: {
+        to: string;
+        data: string;
+        value: string;
+        chainId: number;
+    };
+    /** The raw, exchange-native payload. Always present. */
+    raw: unknown;
+}
 /**
  * A list of UnifiedMarket objects with a convenience match() method.
  * Extends Array so all standard array operations work unchanged.
@@ -393,3 +413,28 @@ export interface EventFilterCriteria {
  * Function type for custom event filtering logic.
  */
 export type EventFilterFunction = (event: UnifiedEvent) => boolean;
+/**
+ * Subscription options.
+ */
+export type SubscriptionOption = 'trades' | 'positions' | 'balances';
+/**
+ * Subscription snapshot of a watched public wallet address.
+ */
+export interface SubscribedAddressSnapshot {
+    /** The wallet address being watched */
+    address: string;
+    /** Recent trades for this address
+     * (if the above SubscriptionOption 'trades' option was requested)
+     */
+    trades?: Trade[];
+    /** Current open positions for this address
+     * (if the above SubscriptionOption 'positions' option was requested)
+     */
+    positions?: Position[];
+    /** Current balances for this address
+     * (if the above SubscriptionOption 'balances' option was requested)
+     */
+    balances?: Balance[];
+    /** Unix timestamp (ms) of this snapshot */
+    timestamp: number;
+}

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

@@ -10,7 +10,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { BaseResponse, BuildOrder200Response, BuildOrderRequest, CancelOrderRequest, CloseRequest, CreateOrder200Response, CreateOrderRequest, 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, FetchTradesRequest, FilterEventsRequest, FilterMarketsRequest, GetExecutionPrice200Response, GetExecutionPriceDetailed200Response, GetExecutionPriceDetailedRequest, GetExecutionPriceRequest, HealthCheck200Response, LoadMarkets200Response, LoadMarketsRequest, SubmitOrderRequest, WatchOrderBookRequest, WatchTradesRequest } from '../models/index';
+import type { BaseResponse, BuildOrder200Response, BuildOrderRequest, CancelOrderRequest, CloseRequest, CreateOrder200Response, CreateOrderRequest, 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, FetchTradesRequest, FilterEventsRequest, FilterMarketsRequest, GetExecutionPrice200Response, GetExecutionPriceDetailed200Response, GetExecutionPriceDetailedRequest, GetExecutionPriceRequest, HealthCheck200Response, LoadMarkets200Response, LoadMarketsRequest, SubmitOrderRequest, UnwatchAddressRequest, WatchAddress200Response, WatchAddressRequest, WatchOrderBookRequest, WatchTradesRequest } from '../models/index';
 export interface BuildOrderOperationRequest {
     exchange: BuildOrderOperationExchangeEnum;
     buildOrderRequest?: BuildOrderRequest;
@@ -111,6 +111,14 @@ export interface SubmitOrderOperationRequest {
     exchange: SubmitOrderOperationExchangeEnum;
     submitOrderRequest?: SubmitOrderRequest;
 }
+export interface UnwatchAddressOperationRequest {
+    exchange: UnwatchAddressOperationExchangeEnum;
+    unwatchAddressRequest?: UnwatchAddressRequest;
+}
+export interface WatchAddressOperationRequest {
+    exchange: WatchAddressOperationExchangeEnum;
+    watchAddressRequest?: WatchAddressRequest;
+}
 export interface WatchOrderBookOperationRequest {
     exchange: WatchOrderBookOperationExchangeEnum;
     watchOrderBookRequest?: WatchOrderBookRequest;
@@ -375,6 +383,26 @@ export declare class DefaultApi extends runtime.BaseAPI {
      * Submit Order
      */
     submitOrder(requestParameters: SubmitOrderOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateOrder200Response>;
+    /**
+     * Stop watching a previously registered wallet address and release its resource updates.
+     * Unwatch Address
+     */
+    unwatchAddressRaw(requestParameters: UnwatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>>;
+    /**
+     * Stop watching a previously registered wallet address and release its resource updates.
+     * Unwatch Address
+     */
+    unwatchAddress(requestParameters: UnwatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse>;
+    /**
+     * 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).
+     * Watch Address
+     */
+    watchAddressRaw(requestParameters: WatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchAddress200Response>>;
+    /**
+     * 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).
+     * Watch Address
+     */
+    watchAddress(requestParameters: WatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchAddress200Response>;
     /**
      * 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
@@ -696,6 +724,30 @@ export declare const SubmitOrderOperationExchangeEnum: {
     readonly Myriad: "myriad";
 };
 export type SubmitOrderOperationExchangeEnum = typeof SubmitOrderOperationExchangeEnum[keyof typeof SubmitOrderOperationExchangeEnum];
+/**
+ * @export
+ */
+export declare const UnwatchAddressOperationExchangeEnum: {
+    readonly Polymarket: "polymarket";
+    readonly Kalshi: "kalshi";
+    readonly Limitless: "limitless";
+    readonly Probable: "probable";
+    readonly Baozi: "baozi";
+    readonly Myriad: "myriad";
+};
+export type UnwatchAddressOperationExchangeEnum = typeof UnwatchAddressOperationExchangeEnum[keyof typeof UnwatchAddressOperationExchangeEnum];
+/**
+ * @export
+ */
+export declare const WatchAddressOperationExchangeEnum: {
+    readonly Polymarket: "polymarket";
+    readonly Kalshi: "kalshi";
+    readonly Limitless: "limitless";
+    readonly Probable: "probable";
+    readonly Baozi: "baozi";
+    readonly Myriad: "myriad";
+};
+export type WatchAddressOperationExchangeEnum = typeof WatchAddressOperationExchangeEnum[keyof typeof WatchAddressOperationExchangeEnum];
 /**
  * @export
  */