camstreamerlib 4.0.0-beta.47 → 4.0.0-beta.49

package/esm/node/WsClient.js

@@ -1,7 +1,6 @@
-import EventEmitter from 'events';
 import WebSocket from 'ws';
 import { Digest } from './Digest';
-export class WsClient extends EventEmitter {
+export class WsClient {
     user;
     pass;
     address;
@@ -14,7 +13,6 @@ export class WsClient extends EventEmitter {
     ws;
     isClosed = false;
     constructor(options) {
-        super();
         const tls = options.tls ?? false;
         const tlsInsecure = options.tlsInsecure ?? false;
         const ip = options.ip ?? '127.0.0.1';
@@ -46,10 +44,10 @@ export class WsClient extends EventEmitter {
             }
             this.ws.binaryType = 'arraybuffer';
             this.isAlive = true;
-            this.pingTimer = setInterval(async () => {
+            this.pingTimer = setInterval(() => {
                 if ((this.ws && this.ws.readyState !== WebSocket.OPEN) || this.isAlive === false) {
-                    this.emit('error', new Error('Connection timeout'));
-                    await this.closeWsConnection();
+                    this.onError(new Error('Connection timeout'));
+                    this.closeWsConnection();
                 }
                 else {
                     this.isAlive = false;
@@ -72,23 +70,32 @@ export class WsClient extends EventEmitter {
                     this.open(res.headers['www-authenticate']);
                 }
                 else {
-                    this.emit('error', new Error('Status code: ' + res.statusCode));
+                    this.onError(new Error('Status code: ' + res.statusCode));
                     this.closeWsConnection();
                 }
             });
-            this.ws.on('open', () => this.emit('open'));
-            this.ws.on('message', (data) => this.emit('message', data));
+            this.ws.on('open', () => this.onOpen());
+            this.ws.on('message', (data, isBinary) => {
+                const message = isBinary ? data : data.toString();
+                this.onMessage(message);
+            });
             this.ws.on('error', (error) => {
-                this.emit('error', error);
+                this.onError(error);
                 this.closeWsConnection();
             });
             this.ws.on('close', () => this.closeWsConnection());
         }
         catch (error) {
-            this.emit('error', error instanceof Error ? error : new Error('Unknown error'));
+            this.onError(error instanceof Error ? error : new Error('Unknown error'));
             this.closeWsConnection();
         }
     }
+    onMessage = (_) => { };
+    onOpen = () => { };
+    onClose = () => { };
+    onError = (error) => {
+        console.error(error);
+    };
     send(data) {
         if (this.ws === undefined) {
             throw new Error("This websocket hasn't been opened yet.");
@@ -97,7 +104,7 @@ export class WsClient extends EventEmitter {
             this.ws.send(data);
         }
     }
-    close() {
+    destroy() {
         if (this.isClosed) {
             return;
         }
@@ -127,7 +134,7 @@ export class WsClient extends EventEmitter {
                     wsCopy.terminate();
                 }
             }, 5000);
-            this.emit('close');
+            this.onClose();
         }
         catch (err) {
             console.error(err);

package/esm/types/CamOverlayAPI/pipSchema.js

@@ -24,7 +24,7 @@ export const pipSchema = serviceCommonSchema.extend({
         z.literal('overlays=image'),
         z.literal('overlays=application'),
     ]),
-    rotate: z.union([z.literal(0), z.literal(90), z.literal(180), z.literal(270)]),
+    rotate: z.union([z.literal(0), z.literal(90), z.literal(180), z.literal(270)]).default(0),
     dewarping: z.object({
         enabled: z.boolean(),
         rectangle: z.array(z.tuple([z.number(), z.number()])),

package/esm/types/PlaneTrackerAPI.js

@@ -231,6 +231,9 @@ export const serverSettingsSchema = z.object({
         tiltRealKnownPoint: 90,
     }),
 });
+export const getIcaoSchema = z.object({
+    icao: z.string(),
+});
 export const trackingModeSchema = z.object({
     mode: z.union([z.literal('MANUAL'), z.literal('AUTOMATIC')]),
 });

package/esm/types/ws/CamOverlayEvents.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+const coEventsDataSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('authorization'), state: z.string() }),
+    z.object({
+        type: z.literal('ServiceStart'),
+        serviceId: z.number(),
+    }),
+    z.object({
+        type: z.literal('ServiceStop'),
+        serviceId: z.number(),
+    }),
+]);
+export const coEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: coEventsDataSchema }),
+    ...coEventsDataSchema.options,
+]);

package/esm/types/ws/CamStreamerEvents.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+const csEventsDataSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('authorization'), state: z.string() }),
+    z.object({
+        type: z.literal('StreamState'),
+        streamID: z.number(),
+        enabled: z.union([z.literal(0), z.literal(1)]),
+        active: z.union([z.literal(0), z.literal(1)]),
+        automationState: z.union([z.literal(0), z.literal(1)]),
+        isStreaming: z.union([z.literal(0), z.literal(1)]),
+    }),
+    z.object({
+        type: z.literal('CS_API_SUCCESS'),
+        apiCall: z.string(),
+        message: z.string(),
+        streamID: z.string(),
+    }),
+    z.object({
+        type: z.literal('CS_API_ERROR'),
+        apiCall: z.string(),
+        message: z.string(),
+        streamID: z.string(),
+        code: z.string(),
+    }),
+]);
+export const csEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: csEventsDataSchema }),
+    ...csEventsDataSchema.options,
+]);

package/esm/types/ws/PlaneTrackerEvents.js

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+const apiFlightDataSchema = z.object({
+    icao: z.string(),
+    lat: z.number(),
+    lon: z.number(),
+    heading: z.number(),
+    groundSpeed: z.number(),
+    altitudeAMSL: z.number(),
+    cameraDistance: z.number(),
+    autoTrackingOrder: z.number(),
+    whiteListed: z.boolean(),
+    blackListed: z.boolean(),
+    priorityListed: z.boolean(),
+    autoSelectionIgnored: z.boolean(),
+    signalQuality: z.number(),
+    emergencyState: z.boolean(),
+    emergencyStatusMessage: z.string(),
+});
+const apiUserSchema = z.object({
+    userId: z.string(),
+    userName: z.string(),
+    userPriority: z.string(),
+    ip: z.string(),
+});
+export var EUserActions;
+(function (EUserActions) {
+    EUserActions["TRACK_ICAO"] = "trackIcao.cgi";
+    EUserActions["RESET_ICAO"] = "resetIcao.cgi";
+    EUserActions["SET_PRIORITY_LIST"] = "setPriorityList.cgi";
+    EUserActions["SET_BLACK_LIST"] = "setBlackList.cgi";
+    EUserActions["SET_WHITE_LIST"] = "setWhiteList.cgi";
+    EUserActions["GO_TO_COORDINATES"] = "goToCoordinates.cgi";
+    EUserActions["SET_TRACKING_MODE"] = "setTrackingMode.cgi";
+    EUserActions["SET_ZONES"] = "setZones.cgi";
+    EUserActions["RESET_PTZ_CALIBRATION"] = "resetPtzCalibration.cgi";
+    EUserActions["LOCK_API"] = "lockApi.cgi";
+    EUserActions["UNLOCK_API"] = "unlockApi.cgi";
+})(EUserActions || (EUserActions = {}));
+const ptrEventsDataSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('CAMERA_POSITION'),
+        lat: z.number(),
+        lon: z.number(),
+        azimuth: z.number().min(0).max(360),
+        elevation: z.number().min(-90).max(90),
+        fov: z.number(),
+    }),
+    z.object({
+        type: z.literal('TRACKING_START'),
+        icao: z.string(),
+    }),
+    z.object({
+        type: z.literal('TRACKING_STOP'),
+    }),
+    z.object({
+        type: z.literal('FLIGHT_LIST'),
+        list: z.array(apiFlightDataSchema),
+    }),
+    z.object({
+        type: z.literal('USER_ACTION'),
+        ip: z.string(),
+        params: z.object({
+            userId: z.string(),
+            userName: z.string(),
+            userPriority: z.number(),
+        }),
+        cgi: z.enum([
+            EUserActions.TRACK_ICAO,
+            EUserActions.RESET_ICAO,
+            EUserActions.SET_PRIORITY_LIST,
+            EUserActions.SET_BLACK_LIST,
+            EUserActions.SET_WHITE_LIST,
+            EUserActions.GO_TO_COORDINATES,
+            EUserActions.SET_TRACKING_MODE,
+            EUserActions.SET_ZONES,
+            EUserActions.RESET_PTZ_CALIBRATION,
+            EUserActions.LOCK_API,
+            EUserActions.UNLOCK_API,
+        ]),
+        postJsonBody: z.any(),
+    }),
+    z.object({
+        type: z.literal('CONNECTED_USERS'),
+        users: z.array(apiUserSchema),
+    }),
+    z.object({
+        type: z.literal('FORCE_TRACKING_STATUS'),
+        enabled: z.boolean(),
+        icao: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal('API_LOCK_STATUS'),
+        isLocked: z.boolean(),
+        user: apiUserSchema.optional(),
+    }),
+]);
+export const ptrEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: ptrEventsDataSchema }),
+    ...ptrEventsDataSchema.options,
+]);

package/esm/web/DefaultClient.js

@@ -1,5 +1,9 @@
 import { addParametersToPath } from '../internal/utils';
 export class DefaultClient {
+    domain;
+    constructor(domain = '') {
+        this.domain = domain;
+    }
     get = (params) => {
         return this.fetchWithTimeout(addParametersToPath(params.path, params.parameters), {
             method: 'GET',
@@ -13,11 +17,11 @@ export class DefaultClient {
             headers: params.headers,
         }, params.timeout);
     };
-    async fetchWithTimeout(url, options, timeout) {
+    async fetchWithTimeout(path, options, timeout) {
         const controller = new AbortController();
         const timeoutId = timeout !== undefined ? setTimeout(() => controller.abort(), timeout) : null;
         try {
-            return await fetch(url, { ...options, signal: controller.signal });
+            return await fetch(`${this.domain}${path}`, { ...options, signal: controller.signal });
         }
         finally {
             if (timeoutId) {

package/esm/web/WsClient.js

@@ -1,13 +1,11 @@
 const REFRESH_TIMEOUT = 5000;
 export class WsClient {
     getUrl;
-    getAuthToken;
     isDestroyed = false;
     ws = null;
     restartTimeout = null;
-    constructor(getUrl, getAuthToken) {
+    constructor(getUrl) {
         this.getUrl = getUrl;
-        this.getAuthToken = getAuthToken;
     }
     init() {
         if (this.isDestroyed) {
@@ -15,17 +13,9 @@ export class WsClient {
         }
         this.destroyWebsocket();
         const ws = new WebSocket(this.getUrl(), 'events');
-        ws.onopen = async () => {
-            try {
-                const token = await this.getAuthToken();
-                ws.send(JSON.stringify({ authorization: token }));
-            }
-            catch (error) {
-                console.error('Error sending auth token:', error);
-                ws.close();
-            }
-        };
-        ws.onmessage = (e) => this.onmessage(e);
+        ws.binaryType = 'arraybuffer';
+        ws.onopen = () => this.onOpen();
+        ws.onmessage = (e) => this.onMessage(e.data);
         ws.onclose = () => {
             this.restartTimeout = window.setTimeout(() => this.init(), REFRESH_TIMEOUT);
         };
@@ -34,7 +24,15 @@ export class WsClient {
     send = (msg) => {
         this.ws?.send(msg);
     };
-    onmessage = (_) => { };
+    onMessage = (_) => { };
+    onOpen = () => { };
+    onClose = () => { };
+    onError = (error) => {
+        console.error(error);
+    };
+    reconnect = () => {
+        this.ws?.close();
+    };
     destroy = () => {
         this.isDestroyed = true;
         this.destroyWebsocket();

package/esm/ws/CamOverlayEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { coEventsSchema } from '../types/ws/CamOverlayEvents';
+export class CamOverlayEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super(coEventsSchema, ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/CamStreamerEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { csEventsSchema } from '../types/ws/CamStreamerEvents';
+export class CamStreamerEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super(csEventsSchema, ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/CamSwitcherEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { cswEventsSchema } from '../types/ws/CamSwitcherEvents';
+export class CamSwitcherEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super(cswEventsSchema, ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/PlaneTrackerEvents.js

@@ -0,0 +1,18 @@
+import { WsEvents } from '../internal/WsEvents';
+import { ptrEventsSchema } from '../types/ws/PlaneTrackerEvents';
+export class PlaneTrackerEvents extends WsEvents {
+    _apiUser;
+    constructor(ws, _apiUser) {
+        super(ptrEventsSchema, ws);
+        this._apiUser = _apiUser;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = () => {
+        this.ws.send(JSON.stringify({
+            type: 'USER_INFO',
+            userId: this._apiUser.userId,
+            userName: this._apiUser.userName,
+            userPriority: this._apiUser.userPriority,
+        }));
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.47",
+    "version": "4.0.0-beta.49",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/CamSwitcherAPI.d.ts

@@ -12,7 +12,7 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     });
     static getProxyPath: () => string;
     static getWsEventsPath: () => string;
-    static getClipPreviewPath: (id: string, storage: TStorageType) => string;
+    static getClipPreviewPath: (clipId: string, storage: TStorageType) => string;
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     getNetworkCameraList(options?: THttpRequestOptions): Promise<{

package/types/PlaneTrackerAPI.d.ts

@@ -1,5 +1,5 @@
 import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
-import { ICAO, TApiUser, TBlackList, TCameraSettings, TExportDataType, TImportDataType, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
+import { ICAO, TApiUser, TBlackList, TCameraSettings, TExportDataType, TGetIcaoByOption, TImportDataType, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
 import { THttpRequestOptions, TProxyParams } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
 export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
@@ -7,6 +7,7 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
     private apiUser;
     constructor(client: Client, apiUser: TApiUser);
     static getProxyPath: () => string;
+    static getWsEventsPath: () => string;
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     serverRunCheck(options?: THttpRequestOptions): Promise<TResponse>;
@@ -177,6 +178,7 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
     setTrackingMode(mode: TTrackingMode['mode'], options?: THttpRequestOptions): Promise<void>;
     startTrackingPlane(icao: ICAO, options?: THttpRequestOptions): Promise<void>;
     stopTrackingPlane(options?: THttpRequestOptions): Promise<void>;
+    getIcao(by: TGetIcaoByOption, value: string, options?: THttpRequestOptions): Promise<string>;
     getPriorityList(options?: THttpRequestOptions): Promise<{
         priorityList: string[];
     }>;
@@ -214,7 +216,7 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
         }[];
     }>;
     setZones(zones: TZones, options?: THttpRequestOptions): Promise<void>;
-    goToCoordinates(lat: number, lon: number, alt?: number, options?: THttpRequestOptions): Promise<TResponse>;
+    goToCoordinates(lat: number, lon: number, alt?: number, options?: THttpRequestOptions): Promise<ReturnType<Client["get"]>>;
     checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<TResponse>;
     getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<{
         value: string;

package/types/index.d.ts

@@ -4,17 +4,23 @@ export * from './internal/utils';
 export * from './internal/versionCompare';
 export * from './internal/ProxyClient';
 export * from './types/common';
-export { CamOverlayAPI } from './CamOverlayAPI';
-export * from './types/CamOverlayAPI';
-export { CamScripterAPI } from './CamScripterAPI';
-export * from './types/CamScripterAPI';
 export { CamStreamerAPI } from './CamStreamerAPI';
 export * from './types/CamStreamerAPI';
+export { CamStreamerEvents } from './ws/CamStreamerEvents';
+export * from './types/ws/CamStreamerEvents';
+export { CamOverlayAPI } from './CamOverlayAPI';
+export * from './types/CamOverlayAPI';
+export { CamOverlayEvents } from './ws/CamOverlayEvents';
+export * from './types/ws/CamOverlayEvents';
 export { CamSwitcherAPI } from './CamSwitcherAPI';
 export * from './types/CamSwitcherAPI';
-export { CamSwitcherEvents } from './CamSwitcherEvents';
-export * from './types/CamSwitcherEvents';
+export { CamSwitcherEvents } from './ws/CamSwitcherEvents';
+export * from './types/ws/CamSwitcherEvents';
 export { PlaneTrackerAPI } from './PlaneTrackerAPI';
 export * from './types/PlaneTrackerAPI';
+export { PlaneTrackerEvents } from './ws/PlaneTrackerEvents';
+export * from './types/ws/PlaneTrackerEvents';
+export { CamScripterAPI } from './CamScripterAPI';
+export * from './types/CamScripterAPI';
 export { VapixAPI } from './VapixAPI';
 export * from './types/VapixAPI';

package/types/internal/WsEvents.d.ts

@@ -1,4 +1,4 @@
-import { IWebsocket } from './types';
+import { IWsClient } from './types';
 type TEventType<T extends {
     type: string;
 }> = T extends {
@@ -22,14 +22,12 @@ type TListenerFunction<T extends {
 }, Type extends TEventType<T>> = (data: TEvent<T, Type>, isInit: boolean) => void;
 export declare class WsEvents<T extends {
     type: string;
-}, Event extends {
-    data: string;
 }> {
     private zodSchema;
-    ws: IWebsocket<Event>;
+    ws: IWsClient;
     private _isDestroyed;
     private listeners;
-    constructor(zodSchema: TZodSchema<T>, ws: IWebsocket<Event>);
+    constructor(zodSchema: TZodSchema<T>, ws: IWsClient);
     get isDestroyed(): boolean;
     resendInitData(): void;
     addListener<Type extends TEventType<T>>(type: Type, listener: TListenerFunction<T, Type>, id: string): void;

package/types/internal/types.d.ts

@@ -9,7 +9,6 @@ export type Options = {
 export type HttpOptions = Options & {
     keepAlive?: boolean;
 };
-export type WsOptions = Options;
 export type TParameters = Record<string, string | number | boolean | null | undefined>;
 export type TResponse = {
     json: () => Promise<any>;
@@ -36,10 +35,12 @@ export interface IClient<TRes extends TResponse, Data> {
     post: (params: TPostParams<Data>) => Promise<TRes>;
 }
 export type TBlobResponse<Client extends IClient<TResponse, any>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
-export interface IWebsocket<Event extends {
-    readonly data: string;
-}> {
+export interface IWsClient {
+    onMessage: null | ((data: ArrayBuffer | string) => void);
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send: (data: ArrayBuffer | string) => void;
+    reconnect: () => void;
     destroy: () => void;
-    onmessage: null | ((event: Event) => void);
-    send: (data: string) => void;
 }

package/types/node/CamScripterAPICameraEventsGenerator.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import EventEmitter from 'events';
-import { WsOptions } from '../internal/types';
+import { Options } from '../internal/types';
 import { TCamScripterEvent, TEventDeclaration, TEventUndeclaration, TCamScripterResponse } from '../types/CamScripterAPICameraEventsGenerator';
 export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
     private tls;
@@ -14,7 +14,7 @@ export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
     private timeoutCheckTimer;
     private wsConnected;
     private ws;
-    constructor(options?: WsOptions);
+    constructor(options?: Options);
     connect(): void;
     disconnect(): void;
     declareEvent(eventDeclaration: TEventDeclaration): Promise<TCamScripterResponse>;

package/types/node/Digest.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/node/VapixEvents.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { WsOptions } from '../internal/types';
+import { Options } from '../internal/types';
 export declare class VapixEvents extends EventEmitter {
     private tls;
     private tlsInsecure;
@@ -8,7 +8,7 @@ export declare class VapixEvents extends EventEmitter {
     private user;
     private pass;
     private ws;
-    constructor(options?: WsOptions);
+    constructor(options?: Options);
     connect(): void;
     disconnect(): void;
     private createWsClient;

package/types/node/WsClient.d.ts

@@ -1,25 +1,11 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import EventEmitter from 'events';
-import { WsOptions } from '../internal/types';
-export type WsClientOptions = WsOptions & {
+import { IWsClient, Options } from '../internal/types';
+export type WsClientOptions = Options & {
     address: string;
     headers?: Record<string, string>;
     pingInterval?: number;
     protocol?: string;
 };
-export interface WsClient {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'message', listener: (data: Buffer) => void): this;
-    on(event: 'error', listener: (err: Error) => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'message', data: Buffer): boolean;
-    emit(event: 'error', err: Error): boolean;
-}
-export declare class WsClient extends EventEmitter {
+export declare class WsClient implements IWsClient {
     private user;
     private pass;
     private address;
@@ -33,8 +19,12 @@ export declare class WsClient extends EventEmitter {
     private isClosed;
     constructor(options: WsClientOptions);
     open(wwwAuthenticateHeader?: string): void;
-    send(data: Buffer | string): void;
-    close(): void;
+    onMessage: (_: ArrayBuffer | string) => void;
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send(data: ArrayBuffer | string): void;
+    destroy(): void;
     reconnect(): void;
     private closeWsConnection;
 }