ccxt 4.1.86 → 4.1.87

package/js/src/pro/bybit.d.ts

@@ -1,38 +1,38 @@
 import bybitRest from '../bybit.js';
-import { Int, OHLCV, Str, Strings } from '../base/types.js';
+import type { Int, OHLCV, Str, Strings, Ticker, OrderBook, Order, Trade, Tickers, Position, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class bybit extends bybitRest {
     describe(): any;
     requestId(): any;
     getUrlByMarketType(symbol?: Str, isPrivate?: boolean, method?: any, params?: {}): any;
     cleanParams(params: any): any;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
-    watchTickers(symbols?: Strings, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): void;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<import("../base/types.js").Dictionary<import("../base/types.js").Dictionary<OHLCV[]>>>;
     handleOHLCV(client: Client, message: any): void;
     parseWsOHLCV(ohlcv: any, market?: any): OHLCV;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    parseWsTrade(trade: any, market?: any): Trade;
     getPrivateType(url: any): "spot" | "unified" | "usdc";
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any): void;
-    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     setPositionsCache(client: Client, symbols?: Strings): any;
     loadPositionsSnapshot(client: any, messageHash: any): Promise<void>;
     handlePositions(client: any, message: any): void;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrder(client: Client, message: any, subscription?: any): void;
-    parseWsSpotOrder(order: any, market?: any): import("../base/types.js").Order;
-    watchBalance(params?: {}): Promise<any>;
+    parseWsSpotOrder(order: any, market?: any): Order;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     parseWsBalance(balance: any, accountType?: any): void;
     watchTopics(url: any, messageHash: any, topics: any, subscriptionHash: any, params?: {}): Promise<any>;

package/js/src/pro/cex.d.ts

@@ -1,48 +1,48 @@
 import cexRest from '../cex.js';
-import { Int, OrderSide, OrderType, Strings, Str } from '../base/types.js';
+import type { Int, OrderSide, OrderType, Strings, Str, OrderBook, Trade, Ticker, Tickers, OHLCV, Order, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class cex extends cexRest {
     describe(): any;
     requestId(): any;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTradesSnapshot(client: Client, message: any): void;
-    parseWsOldTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    parseWsOldTrade(trade: any, market?: any): Trade;
     handleTrade(client: Client, message: any): void;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
-    watchTickers(symbols?: Strings, params?: {}): any;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     fetchTickerWs(symbol: string, params?: {}): Promise<any>;
     handleTicker(client: Client, message: any): void;
-    parseWsTicker(ticker: any, market?: any): import("../base/types.js").Ticker;
-    fetchBalanceWs(params?: {}): Promise<any>;
-    watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    parseWsTicker(ticker: any, market?: any): Ticker;
+    fetchBalanceWs(params?: {}): Promise<Balances>;
+    watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTransaction(client: Client, message: any): void;
     handleMyTrades(client: Client, message: any): void;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    parseWsTrade(trade: any, market?: any): Trade;
     handleOrderUpdate(client: Client, message: any): void;
-    parseWsOrderUpdate(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrderUpdate(order: any, market?: any): Order;
     fromPrecision(amount: any, scale: any): string;
     currencyFromPrecision(currency: any, amount: any): string;
     handleOrdersSnapshot(client: Client, message: any): void;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBookSnapshot(client: Client, message: any): void;
     pairToSymbol(pair: any): string;
     handleOrderBookUpdate(client: Client, message: any): void;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleInitOHLCV(client: Client, message: any): void;
     handleOHLCV24(client: Client, message: any): any;
     handleOHLCV1m(client: Client, message: any): void;
     handleOHLCV(client: Client, message: any): void;
-    fetchOrderWs(id: string, symbol?: string, params?: {}): Promise<import("../base/types.js").Order>;
-    fetchOpenOrdersWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<import("../base/types.js").Order[]>;
-    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<import("../base/types.js").Order>;
-    editOrderWs(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<import("../base/types.js").Order>;
-    cancelOrderWs(id: string, symbol?: string, params?: {}): Promise<import("../base/types.js").Order>;
-    cancelOrdersWs(ids: any, symbol?: string, params?: {}): Promise<import("../base/types.js").Order[]>;
+    fetchOrderWs(id: string, symbol?: string, params?: {}): Promise<Order>;
+    fetchOpenOrdersWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
+    editOrderWs(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<Order>;
+    cancelOrderWs(id: string, symbol?: string, params?: {}): Promise<Order>;
+    cancelOrdersWs(ids: any, symbol?: string, params?: {}): Promise<Order[]>;
     resolveData(client: Client, message: any): void;
     handleConnected(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): void;

package/js/src/pro/coinbase.d.ts

@@ -1,17 +1,18 @@
 import coinbaseRest from '../coinbase.js';
+import { Ticker, Int, Trade, OrderBook, Order } from '../base/types.js';
 export default class coinbase extends coinbaseRest {
     describe(): any;
     subscribe(name: any, symbol?: any, params?: {}): Promise<any>;
-    watchTicker(symbol: any, params?: {}): Promise<any>;
+    watchTicker(symbol: any, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: any, params?: {}): Promise<any>;
     handleTickers(client: any, message: any): any;
-    parseWsTicker(ticker: any, market?: any): import("../base/types.js").Ticker;
-    watchTrades(symbol: any, since?: any, limit?: any, params?: {}): Promise<any>;
-    watchOrders(symbol?: any, since?: any, limit?: any, params?: {}): Promise<any>;
-    watchOrderBook(symbol: any, limit?: any, params?: {}): Promise<any>;
+    parseWsTicker(ticker: any, market?: any): Ticker;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchOrders(symbol?: any, since?: any, limit?: any, params?: {}): Promise<Order[]>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleTrade(client: any, message: any): any;
     handleOrder(client: any, message: any): any;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     handleOrderBookHelper(orderbook: any, updates: any): void;
     handleOrderBook(client: any, message: any): any;
     handleSubscriptionStatus(client: any, message: any): any;

package/js/src/pro/coinbasepro.d.ts

@@ -1,5 +1,5 @@
 import coinbaseproRest from '../coinbasepro.js';
-import { Int, Ticker, Str, Strings } from '../base/types.js';
+import type { Int, Ticker, Str, Strings, Trade, Order, OrderBook } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class coinbasepro extends coinbaseproRest {
     describe(): any;
@@ -11,22 +11,22 @@ export default class coinbasepro extends coinbaseproRest {
     };
     subscribe(name: any, symbol?: any, messageHashStart?: any, params?: {}): Promise<any>;
     subscribeMultiple(name: any, symbols?: any[], messageHashStart?: any, params?: {}): Promise<any>;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<any>;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchMyTradesForSymbols(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchOrdersForSymbols(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchMyTradesForSymbols(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchOrdersForSymbols(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     handleTrade(client: Client, message: any): any;
     handleMyTrade(client: Client, message: any): any;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    parseWsTrade(trade: any, market?: any): Trade;
     parseWsOrderStatus(status: any): string;
     handleOrder(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     handleTicker(client: Client, message: any): any;
     parseTicker(ticker: any, market?: any): Ticker;
     handleDelta(bookside: any, delta: any): void;

package/js/src/pro/coinex.d.ts

@@ -1,28 +1,28 @@
 import coinexRest from '../coinex.js';
-import { Int, Str, Strings } from '../base/types.js';
+import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class coinex extends coinexRest {
     describe(): any;
     requestId(): any;
     handleTicker(client: Client, message: any): void;
-    parseWSTicker(ticker: any, market?: any): import("../base/types.js").Ticker;
-    watchBalance(params?: {}): Promise<any>;
+    parseWSTicker(ticker: any, market?: any): Ticker;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     handleTrades(client: Client, message: any): void;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    parseWsTrade(trade: any, market?: any): Trade;
     handleOHLCV(client: Client, message: any): void;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
-    watchTickers(symbols?: Strings, params?: {}): Promise<any>;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    fetchOHLCVWs(symbol: any, timeframe?: string, since?: any, limit?: any, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    fetchOHLCVWs(symbol: any, timeframe?: string, since?: any, limit?: any, params?: {}): Promise<OHLCV[]>;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBook(client: Client, message: any): void;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrders(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     parseWsOrderStatus(status: any): string;
     handleMessage(client: Client, message: any): any;
     handleAuthenticationMessage(client: Client, message: any): any;

package/js/src/pro/coinex.js

@@ -409,7 +409,8 @@ export default class coinex extends coinexRest {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
-        return await this.watchTickers([symbol], params);
+        const tickers = await this.watchTickers([symbol], params);
+        return this.safeValue(tickers, symbol);
     }
     async watchTickers(symbols = undefined, params = {}) {
         /**

package/js/src/pro/cryptocom.d.ts

@@ -1,31 +1,31 @@
 import cryptocomRest from '../cryptocom.js';
-import { Int, OrderSide, OrderType, Str, Strings } from '../base/types.js';
+import type { Int, OrderSide, OrderType, Str, Strings, OrderBook, Order, Trade, Ticker, OHLCV, Position, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class cryptocom extends cryptocomRest {
     describe(): any;
     pong(client: any, message: any): Promise<void>;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBookSnapshot(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): void;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrders(client: Client, message: any, subscription?: any): void;
-    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     setPositionsCache(client: Client, type: any, symbols?: Strings): void;
     loadPositionsSnapshot(client: any, messageHash: any): Promise<void>;
     handlePositions(client: any, message: any): void;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
-    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<any>;
+    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     handleOrder(client: Client, message: any): void;
-    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<any>;
+    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
     cancelAllOrdersWs(symbol?: Str, params?: {}): Promise<any>;
     handleCancelAllOrders(client: Client, message: any): void;
     watchPublic(messageHash: any, params?: {}): Promise<any>;

package/js/src/pro/currencycom.d.ts

@@ -1,5 +1,5 @@
 import currencycomRest from '../currencycom.js';
-import { Int } from '../base/types.js';
+import type { Int, OrderBook, Trade, Ticker, OHLCV, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class currencycom extends currencycomRest {
     describe(): any;
@@ -32,11 +32,11 @@ export default class currencycom extends currencycomRest {
     requestId(): any;
     watchPublic(destination: any, symbol: any, params?: {}): Promise<any>;
     watchPrivate(destination: any, params?: {}): Promise<any>;
-    watchBalance(params?: {}): Promise<any>;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBook(client: Client, message: any): void;
     handleMessage(client: Client, message: any): any;

package/js/src/pro/deribit.d.ts

@@ -1,25 +1,25 @@
 import deribitRest from '../deribit.js';
-import { Int, Str } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, OHLCV, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class deribit extends deribitRest {
     describe(): any;
     requestId(): any;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any): void;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
     cleanOrderBook(data: any): any;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrders(client: Client, message: any): void;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
     handleMessage(client: Client, message: any): any;
     handleAuthenticationMessage(client: Client, message: any): any;

package/js/src/pro/exmo.d.ts

@@ -1,20 +1,20 @@
 import exmoRest from '../exmo.js';
-import { Int, Str } from '../base/types.js';
+import type { Int, Str, OrderBook, Trade, Ticker, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class exmo extends exmoRest {
     describe(): any;
     requestId(): any;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     parseSpotBalance(message: any): void;
     parseMarginBalance(message: any): void;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any): void;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;

package/js/src/pro/gate.d.ts

@@ -1,31 +1,31 @@
 import gateRest from '../gate.js';
-import { Int, Str, Strings } from '../base/types.js';
+import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Position, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class gate extends gateRest {
     describe(): any;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
     handleOrderBook(client: Client, message: any): void;
     getCacheIndex(orderBook: any, cache: any): any;
     handleBidAsks(bookSide: any, bidAsks: any): void;
     handleDelta(orderbook: any, delta: any): void;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
-    watchTickers(symbols?: Strings, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any): void;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
-    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     setPositionsCache(client: Client, type: any, symbols?: Strings): void;
     loadPositionsSnapshot(client: any, messageHash: any, type: any): Promise<void>;
     handlePositions(client: any, message: any): void;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrder(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): boolean;
     handleBalanceSubscription(client: Client, message: any, subscription?: any): void;

package/js/src/pro/gemini.d.ts

@@ -1,22 +1,22 @@
 import geminiRest from '../gemini.js';
-import { Int, Str } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, OHLCV } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class gemini extends geminiRest {
     describe(): any;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    parseWsTrade(trade: any, market?: any): Trade;
     handleTrade(client: Client, message: any): void;
     handleTrades(client: Client, message: any): void;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): any;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
     handleL2Updates(client: Client, message: any): void;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleHeartbeat(client: Client, message: any): any;
     handleSubscription(client: Client, message: any): any;
     handleOrder(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     parseWsOrderStatus(status: any): string;
     parseWsOrderType(type: any): string;
     handleError(client: Client, message: any): void;

package/js/src/pro/hitbtc.d.ts

@@ -1,38 +1,38 @@
 import hitbtcRest from '../hitbtc.js';
-import { Int, OHLCV, OrderSide, OrderType, Strings } from '../base/types.js';
+import type { Int, OHLCV, OrderSide, OrderType, Strings } from '../base/types.js';
 import Client from '../base/ws/Client.js';
-import { Str, Trade } from '../base/types';
+import { Str, OrderBook, Order, Trade, Ticker, Balances } from '../base/types';
 export default class hitbtc extends hitbtcRest {
     describe(): any;
     authenticate(): Promise<any>;
     subscribePublic(name: string, symbols?: Strings, params?: {}): Promise<any>;
     subscribePrivate(name: string, symbol?: Str, params?: {}): Promise<any>;
     tradeRequest(name: string, params?: {}): Promise<any>;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: any, params?: {}): Promise<any>;
     handleTicker(client: Client, message: any): any;
-    parseWsTicker(ticker: any, market?: any): import("../base/types.js").Ticker;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    parseWsTicker(ticker: any, market?: any): Ticker;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): any;
     parseWsTrades(trades: any, market?: object, since?: Int, limit?: Int, params?: {}): Trade[];
     parseWsTrade(trade: any, market?: any): Trade;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): any;
     parseWsOHLCV(ohlcv: any, market?: any): OHLCV;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrder(client: Client, message: any): any;
     handleOrderHelper(client: Client, message: any, order: any): void;
     parseWsOrderTrade(trade: any, market?: any): Trade;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
-    watchBalance(params?: {}): Promise<any>;
-    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<any>;
-    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<any>;
+    parseWsOrder(order: any, market?: any): Order;
+    watchBalance(params?: {}): Promise<Balances>;
+    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
+    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
     cancelAllOrdersWs(symbol?: Str, params?: {}): Promise<any>;
-    fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleBalance(client: Client, message: any): void;
     handleNotification(client: Client, message: any): any;
     handleOrderRequest(client: Client, message: any): any;

package/js/src/pro/hollaex.d.ts

@@ -1,17 +1,17 @@
 import hollaexRest from '../hollaex.js';
-import { Int, Str } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class hollaex extends hollaexRest {
     describe(): any;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any, subscription?: any): number;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrder(client: Client, message: any, subscription?: any): number;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     watchPublic(messageHash: any, params?: {}): Promise<any>;
     watchPrivate(messageHash: any, params?: {}): Promise<any>;

package/js/src/pro/htx.d.ts

@@ -1,16 +1,16 @@
 import htxRest from '../htx.js';
-import { Int, Str, Strings } from '../base/types.js';
+import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, OHLCV, Position, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class htx extends htxRest {
     describe(): any;
     requestId(): any;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): any;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): any;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBookSnapshot(client: Client, message: any, subscription: any): void;
     watchOrderBookSnapshot(client: any, message: any, subscription: any): Promise<any>;
     handleDelta(bookside: any, delta: any): void;
@@ -18,15 +18,15 @@ export default class htx extends htxRest {
     handleOrderBookMessage(client: Client, message: any): void;
     handleOrderBook(client: Client, message: any): void;
     handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     getOrderChannelAndMessageHash(type: any, subType: any, market?: any, params?: {}): any[];
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrder(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
-    parseOrderTrade(trade: any, market?: any): import("../base/types.js").Trade;
-    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    parseWsOrder(order: any, market?: any): Order;
+    parseOrderTrade(trade: any, market?: any): Trade;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     handlePositions(client: any, message: any): void;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     handleSubscriptionStatus(client: Client, message: any): any;
     handleSystemStatus(client: Client, message: any): any;
@@ -37,7 +37,7 @@ export default class htx extends htxRest {
     handleErrorMessage(client: Client, message: any): any;
     handleMessage(client: Client, message: any): void;
     handleMyTrade(client: Client, message: any, extendParams?: {}): void;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    parseWsTrade(trade: any, market?: any): Trade;
     getUrlByMarketType(type: any, isLinear?: boolean, isPrivate?: boolean, isFeed?: boolean): any;
     subscribePublic(url: any, symbol: any, messageHash: any, method?: any, params?: {}): Promise<any>;
     subscribePrivate(channel: any, messageHash: any, type: any, subtype: any, params?: {}, subscriptionParams?: {}): Promise<any>;

package/js/src/pro/huobijp.d.ts

@@ -1,16 +1,16 @@
 import huobijpRest from '../huobijp.js';
-import { Int } from '../base/types.js';
+import type { Int, OrderBook, Trade, Ticker, OHLCV } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class huobijp extends huobijpRest {
     describe(): any;
     requestId(): any;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): any;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): any;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBookSnapshot(client: Client, message: any, subscription: any): void;
     watchOrderBookSnapshot(client: any, message: any, subscription: any): Promise<any>;
     handleDelta(bookside: any, delta: any): void;