kucoin-api 2.1.23 → 2.2.0

package/README.md

@@ -1,4 +1,11 @@
-# Node.js & JavaScript SDK for Kucoin REST APIs & Websockets
+# Node.js & JavaScript SDK for Kucoin REST APIs, Websockets & WebSocket API
+
+[![Build & Test](https://github.com/tiagosiebler/kucoin-api/actions/workflows/e2etest.yml/badge.svg?branch=master)](https://github.com/tiagosiebler/kucoin-api/actions/workflows/e2etest.yml)
+[![npm version](https://img.shields.io/npm/v/kucoin-api)][1]
+[![npm size](https://img.shields.io/bundlephobia/min/kucoin-api/latest)][1]
+[![npm downloads](https://img.shields.io/npm/dt/kucoin-api)][1]
+[![last commit](https://img.shields.io/github/last-commit/tiagosiebler/kucoin-api)][1]
+[![Telegram](https://img.shields.io/badge/chat-on%20telegram-blue.svg)](https://t.me/nodetraders)
 
 <p align="center">
   <a href="https://www.npmjs.com/package/kucoin-api">
@@ -9,13 +16,6 @@
   </a>
 </p>
 
-[![npm version](https://img.shields.io/npm/v/kucoin-api)][1]
-[![npm size](https://img.shields.io/bundlephobia/min/kucoin-api/latest)][1]
-[![npm downloads](https://img.shields.io/npm/dt/kucoin-api)][1]
-[![Build & Test](https://github.com/tiagosiebler/kucoin-api/actions/workflows/e2etest.yml/badge.svg?branch=master)](https://github.com/tiagosiebler/kucoin-api/actions/workflows/e2etest.yml)
-[![last commit](https://img.shields.io/github/last-commit/tiagosiebler/kucoin-api)][1]
-[![Telegram](https://img.shields.io/badge/chat-on%20telegram-blue.svg)](https://t.me/nodetraders)
-
 [1]: https://www.npmjs.com/package/kucoin-api
 
 Updated & performant JavaScript & Node.js SDK for the Kucoin REST APIs and WebSockets:
@@ -24,6 +24,7 @@ Updated & performant JavaScript & Node.js SDK for the Kucoin REST APIs and WebSo
 - Complete integration with all Kucoin REST APIs and WebSockets.
   - Dedicated REST clients for Spot, Futures, and Broker operations
   - Unified WebSocket client for all markets
+  - Dedicated WebSocket API client, to trade on the WebSocket API without the complexity of WebSockets.
 - Complete TypeScript support (with type declarations for most API requests & responses).
   - Strongly typed requests and responses.
   - Automated end-to-end tests ensuring reliability.
@@ -33,6 +34,9 @@ Updated & performant JavaScript & Node.js SDK for the Kucoin REST APIs and WebSo
   - Smart WebSocket persistence with automatic reconnection handling.
   - Emit `reconnected` event when dropped connection is restored.
   - Support for both public and private WebSocket streams.
+- Supports WebSocket API on all available product groups, including Spot & Futures:
+  - Use the WebsocketClient's event-driven `sendWSAPIRequest()` method, or;
+  - Use the WebsocketAPIClient for a REST-like experience. Use the WebSocket API like a REST API! See [examples/WebSockets/ws-api-client.ts](./examples/WebSockets/ws-api-client.ts) for a demonstration.
 - Browser-friendly HMAC signature mechanism.
 - Automatically supports both ESM and CJS projects.
 - Heavy automated end-to-end testing with real API calls.
@@ -52,9 +56,13 @@ Updated & performant JavaScript & Node.js SDK for the Kucoin REST APIs and WebSo
     - [Spot & Margin Trading](#spot--margin-trading)
     - [Futures Trading](#futures-trading)
     - [Broker Operations](#broker-operations)
-  - [WebSocket Client](#websockets)
-    - [Public WebSocket Streams](#public-websocket-streams)
-    - [Private WebSocket Streams](#private-websocket-streams)
+  - [WebSockets](#websockets)
+    - [WebSocket Consumers](#websocket-consumers)
+      - [Public WebSocket Streams](#public-websocket-streams)
+      - [Private WebSocket Streams](#private-websocket-streams)
+    - [WebSocket API](#websocket-api)
+      - [Event Driven API](#event-driven-api)
+      - [Promise Driven API](#async-await-api)
 - [Customise Logging](#customise-logging)
 - [LLMs & AI](#use-with-llms--ai)
 - [Used By](#used-by)
@@ -194,7 +202,11 @@ Key WebSocket features:
 - Support for both public and private WebSocket streams
 - Unified client for spot and futures markets
 
-### Public WebSocket Streams
+### WebSocket Consumers
+
+All websockets are accessible via the shared `WebsocketClient`. As before, API credentials are optional unless the user data stream is required.
+
+#### Public WebSocket Streams
 
 For public market data, API credentials are not required:
 
@@ -278,12 +290,97 @@ try {
 }
 ```
 
-### Private WebSocket Streams
+#### Private WebSocket Streams
 
 For private account data streams, API credentials are required. The WebsocketClient will automatically handle authentication when you provide API credentials.
 
 See [WebsocketClient](./src/WebsocketClient.ts) for further information and make sure to check the [examples](./examples/) folder for much more detail, especially [ws-spot-public.ts](./examples/ws-spot-public.ts), which explains a lot of detail.
 
+### WebSocket API
+
+Kucoin also support sending requests (commands) over an active WebSocket connection. This is called the WebSocket API. There are two key ways of interacting with the WebSocket API. The existing WebsocketClient allows raw event routing via the awaitable sendWSAPIRequest() method, or for a much simpler & convenient interface, use the promise-driven API. The surface feels like a REST API, but routing is automatically routed via a dedicated WebSocket connection.
+
+#### Event Driven API
+
+The WebSocket API is available in the [WebsocketClient](./src/websocket-client.ts) via the `sendWSAPIRequest(wsKey, command, commandParameters)` method.
+
+Each call to this method is wrapped in a promise, which you can async await for a response, or handle it in a raw event-driven design.
+
+#### Promise Driven API
+
+The WebSocket API is also available in a promise-wrapped REST-like format. Either, as above, await any calls to `sendWSAPIRequest(...)`, or directly use the convenient WebsocketAPIClient. This class is very similar to existing REST API classes (such as the MainClient or USDMClient).
+
+It provides one function per endpoint, feels like a REST API and will automatically route your request via an automatically persisted, authenticated and health-checked WebSocket API connection.
+
+Below is an example showing how easy it is to use the WebSocket API without any concern for the complexity of managing WebSockets. For more detailed demonstration, take a look at the [examples/WebSockets/ws-api-client.ts](./examples/WebSockets//ws-api-client.ts) example:
+
+```typescript
+import { DefaultLogger, WebsocketAPIClient } from 'kucoin-api';
+
+// or, if you prefer `require()`:
+// const { DefaultLogger, WebsocketAPIClient } = require('kucoin-api');
+
+const customLogger = {
+  ...DefaultLogger,
+  // For a more detailed view of the WebsocketClient, enable the `trace` level by uncommenting the below line:
+  // trace: (...params) => console.log(new Date(), 'trace', ...params),
+};
+
+const account = {
+  key: process.env.API_KEY || 'keyHere',
+  secret: process.env.API_SECRET || 'secretHere',
+  passphrase: process.env.API_PASSPHRASE || 'apiPassPhraseHere', // This is NOT your account password
+};
+
+const wsClient = new WebsocketAPIClient(
+  {
+    apiKey: account.key,
+    apiSecret: account.secret,
+    apiPassphrase: account.passphrase,
+
+    // If you want your own event handlers instead of the default ones with logs, disable this setting and see the `attachEventHandlers` example below:
+    // attachEventListeners: false
+  },
+  // customLogger, // optional: uncomment this to inject a custom logger
+);
+
+// Make WebSocket API calls, very similar to a REST API:
+
+wsClient
+  .submitNewSpotOrder({
+    side: 'buy',
+    symbol: 'BTC-USDT',
+    type: 'limit',
+    price: '150000',
+    size: '0.0001',
+  })
+  .then((syncSpotOrderResponse) => {
+    console.log('Sync spot order response:', syncSpotOrderResponse);
+  })
+  .catch((e) => {
+    console.log('Sync spot order error:', e);
+  });
+
+wsClient
+  .submitFuturesOrder({
+    clientOid: 'futures-test-' + Date.now(),
+    side: 'buy',
+    symbol: 'XBTUSDTM',
+    marginMode: 'CROSS',
+    type: 'limit',
+    price: '1000',
+    qty: '0.01',
+    leverage: 10,
+    positionSide: 'LONG', // needed if trading two-way (hedge) position mode
+  })
+  .then((futuresOrderResponse) => {
+    console.log('Futures order response:', futuresOrderResponse);
+  })
+  .catch((e) => {
+    console.log('Futures order error:', e);
+  });
+```
+
 ---
 
 ## Customise Logging
@@ -301,8 +398,8 @@ const logger = {
   trace: (...params) => {
     if (
       [
+        // Selectively prevent some traces from logging
         'Sending ping',
-        // 'Sending upstream ws message: ',
         'Received pong',
       ].includes(params[0])
     ) {

package/dist/cjs/WebsocketAPIClient.d.ts

@@ -0,0 +1,123 @@
+import { DefaultLogger } from './lib/websocket/logger.js';
+import { WSAPIWsKey } from './lib/websocket/websocket-util.js';
+import { BatchCancelOrdersRequest, Order } from './types/request/futures.types.js';
+import { SubmitHFMarginOrderRequest } from './types/request/spot-margin-trading.js';
+import { ModifyHFOrderRequest, SubmitHFOrderRequest } from './types/request/spot-trading.js';
+import { BatchCancelOrderResult, SubmitMultipleOrdersFuturesResponse } from './types/response/futures.types.js';
+import { MarginSubmitOrderV3Response } from './types/response/spot-margin-trading.js';
+import { SubmitHFOrderSyncResponse, SyncCancelHFOrderResponse } from './types/response/spot-trading.js';
+import { WSAPICancelOrderRequest, WSAPIOrderResponse, WSAPIResponse } from './types/websockets/ws-api.js';
+import { WSClientConfigurableOptions } from './types/websockets/ws-general.js';
+import { WebsocketClient } from './WebsocketClient.js';
+/**
+ * Configurable options specific to only the REST-like WebsocketAPIClient
+ */
+export interface WSAPIClientConfigurableOptions {
+    /**
+     * Default: true
+     *
+     * Attach default event listeners, which will console log any high level
+     * events (opened/reconnecting/reconnected/etc).
+     *
+     * If you disable this, you should set your own event listeners
+     * on the embedded WS Client `wsApiClient.getWSClient().on(....)`.
+     */
+    attachEventListeners: boolean;
+}
+/**
+ * This is a minimal Websocket API wrapper around the WebsocketClient.
+ *
+ * Some methods support passing in a custom "wsKey". This is a reference to which WS connection should
+ * be used to transmit that message. This is only useful if you wish to use an alternative wss
+ * domain that is supported by the SDK.
+ *
+ * Note: To use testnet, don't set the wsKey - use `testnet: true` in
+ * the constructor instead.
+ *
+ * Note: You can also directly use the sendWSAPIRequest() method to make WS API calls, but some
+ * may find the below methods slightly more intuitive.
+ *
+ * Refer to the WS API promises example for a more detailed example on using sendWSAPIRequest() directly:
+ * https://github.com/tiagosiebler/binance/blob/master/examples/WebSockets/ws-api-raw-promises.ts#L108
+ */
+export declare class WebsocketAPIClient {
+    private wsClient;
+    private options;
+    constructor(options?: WSClientConfigurableOptions & Partial<WSAPIClientConfigurableOptions>, logger?: DefaultLogger);
+    getWSClient(): WebsocketClient;
+    /**
+     * Submit a spot order
+     */
+    submitNewSpotOrder(params: SubmitHFOrderRequest, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<WSAPIOrderResponse>>;
+    /**
+     * Modify a spot order
+     */
+    modifySpotOrder(params: ModifyHFOrderRequest, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<{
+        newOrderId: string;
+        clientOid: string;
+    }>>;
+    /**
+     * Cancel a spot order
+     */
+    cancelSpotOrder(params: WSAPICancelOrderRequest, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<WSAPIOrderResponse>>;
+    /**
+     * Submit a sync spot order
+     */
+    submitSyncSpotOrder(params: SubmitHFOrderRequest, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<SubmitHFOrderSyncResponse>>;
+    /**
+     * Cancel a sync spot order
+     */
+    cancelSyncSpotOrder(params: WSAPICancelOrderRequest, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<SyncCancelHFOrderResponse>>;
+    /**
+     * Submit a margin order
+     */
+    submitMarginOrder(params: SubmitHFMarginOrderRequest, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<MarginSubmitOrderV3Response>>;
+    /**
+     * Cancel a margin order
+     */
+    cancelMarginOrder(params: WSAPICancelOrderRequest, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<WSAPIOrderResponse>>;
+    /**
+     * Submit a futures order
+     */
+    submitFuturesOrder(params: Order, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<WSAPIOrderResponse>>;
+    /**
+     * Cancel a futures order
+     */
+    cancelFuturesOrder(params: {
+        orderId: string;
+    } | {
+        clientOid: string;
+        symbol: string;
+    }, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<{
+        cancelledOrderIds: string[];
+    } | {
+        clientOid: string;
+    }>>;
+    /**
+     * Submit multiple futures orders
+     */
+    submitMultipleFuturesOrders(params: Order[], wsKey?: WSAPIWsKey): Promise<WSAPIResponse<SubmitMultipleOrdersFuturesResponse[]>>;
+    /**
+     * Cancel multiple futures orders
+     */
+    cancelMultipleFuturesOrders(params: BatchCancelOrdersRequest, wsKey?: WSAPIWsKey): Promise<WSAPIResponse<BatchCancelOrderResult[]>>;
+    /**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     * Private methods for handling some of the convenience/automation provided by the WS API Client
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    connectWSAPI(wsKey: WSAPIWsKey): Promise<unknown>;
+    private setupDefaultEventListeners;
+}

package/dist/cjs/WebsocketAPIClient.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketAPIClient = void 0;
+const websocket_util_js_1 = require("./lib/websocket/websocket-util.js");
+const WebsocketClient_js_1 = require("./WebsocketClient.js");
+/**
+ * This is a minimal Websocket API wrapper around the WebsocketClient.
+ *
+ * Some methods support passing in a custom "wsKey". This is a reference to which WS connection should
+ * be used to transmit that message. This is only useful if you wish to use an alternative wss
+ * domain that is supported by the SDK.
+ *
+ * Note: To use testnet, don't set the wsKey - use `testnet: true` in
+ * the constructor instead.
+ *
+ * Note: You can also directly use the sendWSAPIRequest() method to make WS API calls, but some
+ * may find the below methods slightly more intuitive.
+ *
+ * Refer to the WS API promises example for a more detailed example on using sendWSAPIRequest() directly:
+ * https://github.com/tiagosiebler/binance/blob/master/examples/WebSockets/ws-api-raw-promises.ts#L108
+ */
+class WebsocketAPIClient {
+    wsClient;
+    options;
+    constructor(options, logger) {
+        this.wsClient = new WebsocketClient_js_1.WebsocketClient(options, logger);
+        this.options = {
+            attachEventListeners: true,
+            ...options,
+        };
+        this.setupDefaultEventListeners();
+    }
+    getWSClient() {
+        return this.wsClient;
+    }
+    /**
+     * Submit a spot order
+     */
+    submitNewSpotOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiSpotV1, 'spot.order', params);
+    }
+    /**
+     * Modify a spot order
+     */
+    modifySpotOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiSpotV1, 'spot.modify', params);
+    }
+    /**
+     * Cancel a spot order
+     */
+    cancelSpotOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiSpotV1, 'spot.cancel', params);
+    }
+    /**
+     * Submit a sync spot order
+     */
+    submitSyncSpotOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiSpotV1, 'spot.sync_order', params);
+    }
+    /**
+     * Cancel a sync spot order
+     */
+    cancelSyncSpotOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiSpotV1, 'spot.sync_cancel', params);
+    }
+    /**
+     * Submit a margin order
+     */
+    submitMarginOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiSpotV1, 'margin.order', params);
+    }
+    /**
+     * Cancel a margin order
+     */
+    cancelMarginOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiSpotV1, 'margin.cancel', params);
+    }
+    /**
+     * Submit a futures order
+     */
+    submitFuturesOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiFuturesV1, 'futures.order', params);
+    }
+    /**
+     * Cancel a futures order
+     */
+    cancelFuturesOrder(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiFuturesV1, 'futures.cancel', params);
+    }
+    /**
+     * Submit multiple futures orders
+     */
+    submitMultipleFuturesOrders(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiFuturesV1, 'futures.multi_order', params);
+    }
+    /**
+     * Cancel multiple futures orders
+     */
+    cancelMultipleFuturesOrders(params, wsKey) {
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_js_1.WS_KEY_MAP.wsApiFuturesV1, 'futures.multi_cancel', params);
+    }
+    /**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     * Private methods for handling some of the convenience/automation provided by the WS API Client
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    connectWSAPI(wsKey) {
+        return this.getWSClient().assertIsAuthenticated(wsKey);
+    }
+    setupDefaultEventListeners() {
+        if (this.options.attachEventListeners) {
+            /**
+             * General event handlers for monitoring the WebsocketClient
+             */
+            this.wsClient
+                .on('open', (data) => {
+                console.log(new Date(), 'ws connected', data.wsKey);
+            })
+                .on('reconnect', ({ wsKey }) => {
+                console.log(new Date(), 'ws automatically reconnecting.... ', wsKey);
+            })
+                .on('reconnected', (data) => {
+                console.log(new Date(), 'ws has reconnected ', data?.wsKey);
+            })
+                .on('authenticated', (data) => {
+                console.info(new Date(), 'ws has authenticated ', data?.wsKey);
+            })
+                .on('exception', (data) => {
+                console.error(new Date(), 'ws exception: ', JSON.stringify(data));
+            });
+        }
+    }
+}
+exports.WebsocketAPIClient = WebsocketAPIClient;
+//# sourceMappingURL=WebsocketAPIClient.js.map

package/dist/cjs/WebsocketAPIClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsocketAPIClient.js","sourceRoot":"","sources":["../../src/WebsocketAPIClient.ts"],"names":[],"mappings":"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"}

package/dist/cjs/WebsocketClient.d.ts

@@ -1,12 +1,16 @@
 import { BaseWebsocketClient, EmittableEvent } from './lib/BaseWSClient.js';
-import { MessageEventLike, WsKey, WsTopicRequest } from './lib/websocket/websocket-util.js';
+import { WsKey, WsTopicRequest } from './lib/websocket/websocket-util.js';
 import { WSConnectedResult } from './lib/websocket/WsStore.types.js';
-import { WsMarket } from './types/websockets/client.js';
-import { WsOperation } from './types/websockets/requests.js';
-import { WsAPITopicRequestParamMap, WsAPITopicResponseMap, WsAPIWsKeyTopicMap } from './types/websockets/wsAPI.js';
+import { Exact, WSAPIAuthenticationRequestFromServer, WsAPITopicRequestParamMap, WsAPITopicResponseMap, WsAPIWsKeyTopicMap, WsOperation } from './types/websockets/ws-api.js';
+import { MessageEventLike } from './types/websockets/ws-events.js';
+import { WsMarket } from './types/websockets/ws-general.js';
 export declare const WS_LOGGER_CATEGORY: {
     category: string;
 };
+export interface WSAPIRequestFlags {
+    /** If true, will skip auth requirement for WS API connection */
+    authIsOptional?: boolean | undefined;
+}
 /** Any WS keys in this list will ALWAYS skip the authentication process, even if credentials are available */
 export declare const PUBLIC_WS_KEYS: WsKey[];
 /**
@@ -18,6 +22,7 @@ export declare class WebsocketClient extends BaseWebsocketClient<WsKey> {
     private getRESTClient;
     private getRestClientOptions;
     private getWSConnectionInfo;
+    private signMessage;
     /**
      * Request connection of all dependent (public & private) websockets, instead of waiting for automatic connection by library
      */
@@ -40,15 +45,15 @@ export declare class WebsocketClient extends BaseWebsocketClient<WsKey> {
      * - These topics will be removed from the topic cache, so they won't be subscribed to again.
      */
     unsubscribe(requests: (WsTopicRequest<WsTopic> | WsTopic) | (WsTopicRequest<WsTopic> | WsTopic)[], wsKey: WsKey): void;
-    /**
-     * Not supported by Kucoin, do not use
-     */
-    sendWSAPIRequest<TWSKey extends keyof WsAPIWsKeyTopicMap, TWSChannel extends WsAPIWsKeyTopicMap[TWSKey] = WsAPIWsKeyTopicMap[TWSKey], TWSParams extends WsAPITopicRequestParamMap[TWSChannel] = WsAPITopicRequestParamMap[TWSChannel], TWSAPIResponse extends WsAPITopicResponseMap[TWSChannel] | object = WsAPITopicResponseMap[TWSChannel]>(wsKey: TWSKey, channel: TWSChannel, ...params: TWSParams extends undefined ? [] : [TWSParams]): Promise<TWSAPIResponse>;
+    sendWSAPIRequest<TWSKey extends keyof WsAPIWsKeyTopicMap, TWSOperation extends WsAPIWsKeyTopicMap[TWSKey], TWSParams extends Exact<WsAPITopicRequestParamMap[TWSOperation]>, TWSAPIResponse extends WsAPITopicResponseMap[TWSOperation] = WsAPITopicResponseMap[TWSOperation]>(wsKey: TWSKey, operation: TWSOperation, params: TWSParams & {
+        signRequest?: boolean;
+    }, requestFlags?: WSAPIRequestFlags): Promise<TWSAPIResponse>;
     /**
      *
      * Internal methods
      *
      */
+    private signWSAPIRequest;
     /**
      * Whatever url this method returns, it's connected to as-is!
      *
@@ -73,6 +78,6 @@ export declare class WebsocketClient extends BaseWebsocketClient<WsKey> {
      * Map one or more topics into fully prepared "subscribe request" events (already stringified and ready to send)
      */
     protected getWsOperationEventsForTopics(topicRequests: WsTopicRequest<string>[], wsKey: WsKey, operation: WsOperation): Promise<string[]>;
-    protected getWsAuthRequestEvent(wsKey: WsKey): Promise<object>;
+    protected getWsAuthRequestEvent(wsKey: WsKey, eventToAuth?: WSAPIAuthenticationRequestFromServer): Promise<object | string | 'waitForEvent' | void>;
 }
 export {};