camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.3

package/{CamSwitcherAPI.js → esm/CamSwitcherAPI.js}

@@ -15,9 +15,9 @@ export class CamSwitcherAPI {
         this.client = client;
         this.vapixAgent = new VapixAPI(client, () => '');
     }
-    static getProxyUrl = () => `${baseUrl}/proxy.cgi`;
-    static getWsEventsUrl = () => `/local/camswitcher/events`;
-    static getClipPreview = (id, storage) => `${baseUrl}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
+    static getProxyUrlPath = () => `${baseUrl}/proxy.cgi`;
+    static getWsEventsUrlPath = () => `/local/camswitcher/events`;
+    static getClipPreviewUrlPath = (id, storage) => `${baseUrl}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
     async generateSilence(sampleRate, channels) {
         await this.client.get(`${baseUrl}/generate_silence.cgi`, {
             sample_rate: sampleRate.toString(),

package/esm/CamSwitcherEvents.d.ts

@@ -0,0 +1,18 @@
+import { IWebsocket } from './internal/common';
+import { TCamSwitcherEventOfType, TCamSwitcherEventType } from './types/CamSwitcherEvents';
+type TListenerFunction<T extends TCamSwitcherEventType> = (data: TCamSwitcherEventOfType<T>, isInit: boolean) => void;
+export declare class CamSwitcherEvents<Event extends {
+    data: string;
+}> {
+    isDestroyed: boolean;
+    private ws;
+    private listeners;
+    setWebsocket(ws: IWebsocket<Event>): void;
+    resendInitData(): void;
+    addListener<T extends TCamSwitcherEventType>(type: T, listener: TListenerFunction<T>, id: string): void;
+    removeListener<T extends TCamSwitcherEventType>(type: T, id: string): void;
+    private onMessage;
+    private processMessage;
+    destroy(): void;
+}
+export {};

package/{CamSwitcherEvents.js → esm/CamSwitcherEvents.js}

@@ -1,4 +1,4 @@
-import { cswEventsSchema, } from './types/CamswitcherEvents';
+import { cswEventsSchema, } from './types/CamSwitcherEvents';
 export class CamSwitcherEvents {
     isDestroyed = false;
     ws = null;

package/esm/CreatePackage.d.ts

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

package/esm/VapixAPI.d.ts

@@ -0,0 +1,66 @@
+import { IClient, TParameters, TResponse } from './internal/common';
+import { TApplication, TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice } from './types/VapixAPI';
+import { ProxyClient } from './internal/ProxyClient';
+import { TCameraImageConfig, TProxyParam } from './types/common';
+export declare class VapixAPI<Client extends IClient = IClient> {
+    client: ProxyClient<Client>;
+    constructor(client: Client, getProxyUrl: () => string);
+    getUrlEncoded(proxy: TProxyParam | undefined, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
+    postJson(proxy: TProxyParam | undefined, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<TResponse>;
+    getCameraImage(params: TCameraImageConfig, proxy?: TProxyParam): Promise<TResponse>;
+    getEventDeclarations(proxy?: TProxyParam): Promise<string>;
+    getSupportedAudioSampleRate(proxy?: TProxyParam): Promise<TAudioSampleRates[]>;
+    performAutofocus(proxy?: TProxyParam): Promise<void>;
+    checkSDCard(proxy?: TProxyParam): Promise<TSDCardInfo>;
+    mountSDCard(proxy?: TProxyParam): Promise<number>;
+    unmountSDCard(proxy?: TProxyParam): Promise<number>;
+    private _doSDCardMountAction;
+    fetchSDCardJobProgress(jobId: number, proxy?: TProxyParam): Promise<number>;
+    downloadCameraReport(proxy?: TProxyParam): Promise<TResponse>;
+    getSystemLog(proxy?: TProxyParam): Promise<TResponse>;
+    getMaxFps(channel: number, proxy?: TProxyParam): Promise<number>;
+    getTimezone(proxy?: TProxyParam): Promise<string>;
+    getDateTimeInfo(proxy?: TProxyParam): Promise<{
+        data: {
+            dateTime: string;
+            dstEnabled: boolean;
+            localDateTime: string;
+            posixTimeZone: string;
+            timeZone: string;
+        };
+    }>;
+    getDevicesSettings(proxy?: TProxyParam): Promise<TAudioDevice[]>;
+    fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, proxy?: TProxyParam): Promise<any>;
+    getHeaders(proxy?: TProxyParam): Promise<Record<string, string>>;
+    setHeaders(headers: Record<string, string>, proxy?: TProxyParam): Promise<TResponse>;
+    getParameter(paramNames: string | string[], proxy?: TProxyParam): Promise<Record<string, string>>;
+    setParameter(params: Record<string, string | number | boolean>, proxy?: TProxyParam): Promise<boolean>;
+    getGuardTourList(proxy?: TProxyParam): Promise<{
+        name: string;
+        id: string;
+        running: string;
+        tour: {
+            moveSpeed?: unknown;
+            position?: unknown;
+            presetNbr?: unknown;
+            waitTime?: unknown;
+            waitTimeViewType?: unknown;
+        }[];
+        camNbr?: unknown;
+        randomEnabled?: unknown;
+        timeBetweenSequences?: unknown;
+    }[]>;
+    setGuardTourEnabled(guardTourID: string, enable: boolean, proxy?: TProxyParam): Promise<boolean>;
+    getPTZPresetList(channel: number, proxy?: TProxyParam): Promise<string[]>;
+    listPTZ(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItem[]>;
+    listPtzVideoSourceOverview(proxy?: TProxyParam): Promise<TPtzOverview>;
+    goToPreset(channel: number, presetName: string, proxy?: TProxyParam): Promise<TResponse>;
+    getPtzPosition(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItemData>;
+    getInputState(port: number, proxy?: TProxyParam): Promise<boolean>;
+    setOutputState(port: number, active: boolean, proxy?: TProxyParam): Promise<TResponse>;
+    getApplicationList(proxy?: TProxyParam): Promise<TApplication[]>;
+    startApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    restartApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    stopApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    installApplication(data: Blob, fileName: string): Promise<void>;
+}

package/esm/VapixEvents.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { WsOptions } from './internal/common';
+export type VapixEventsOptions = WsOptions;
+type TEventMessage = {
+    apiVersion: string;
+    method: string;
+    params: {
+        notification: {
+            timestamp: number;
+            topic: string;
+            message: {
+                source: Record<string, string>;
+                data: Record<string, string>;
+                key: Record<string, string>;
+            };
+        };
+    };
+};
+export interface VapixEvents {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: string, listener: (data: TEventMessage) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: string, msg: TEventMessage): boolean;
+}
+export declare class VapixEvents extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private ws;
+    constructor(options?: VapixEventsOptions);
+    connect(): void;
+    disconnect(): void;
+    private createWsClient;
+    private isReservedEventName;
+}
+export {};

package/esm/errors/errors.d.ts

@@ -0,0 +1,34 @@
+export declare class ServiceUnavailableError extends Error {
+    constructor();
+}
+export declare class ServiceNotFoundError extends Error {
+    constructor();
+}
+export declare class ParsingBlobError extends Error {
+    constructor(err: unknown);
+}
+type TApplicationAPIAction = 'START' | 'RESTART' | 'STOP';
+export declare class ApplicationAPIError extends Error {
+    constructor(action: TApplicationAPIAction, res: string);
+}
+type TSDCardAction = 'MOUNT' | 'UNMOUNT';
+export declare class SDCardActionError extends Error {
+    constructor(action: TSDCardAction, res: string);
+}
+export declare class SDCardJobError extends Error {
+    constructor();
+}
+type TMaxFPSErrorType = 'MALFORMED_REPLY' | 'CHANNEL_NOT_FOUND' | 'CAPTURE_MODE_NOT_FOUND' | 'FPS_NOT_SPECIFIED';
+export declare class MaxFPSError extends Error {
+    constructor(state: TMaxFPSErrorType);
+}
+export declare class NoDeviceInfoError extends Error {
+    constructor();
+}
+export declare class FetchDeviceInfoError extends Error {
+    constructor(err: unknown);
+}
+export declare class AddNewClipError extends Error {
+    constructor(message: string);
+}
+export {};

package/esm/events/AxisCameraStationEvents.d.ts

@@ -0,0 +1,9 @@
+import { IClient, HttpOptions } from '../internal/common';
+export type AcsEventsOptions = HttpOptions;
+export declare class AxisCameraStationEvents {
+    private sourceKey;
+    private client;
+    constructor(sourceKey: string, opt?: AcsEventsOptions | IClient);
+    sendEvent(data: Record<string, string>, eventType: string): Promise<void>;
+    private getDate;
+}

package/esm/events/GenetecAgent.d.ts

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+declare const cameraGuidsResponseSchema: z.ZodObject<{
+    Rsp: z.ZodObject<{
+        Status: z.ZodString;
+        Result: z.ZodArray<z.ZodObject<{
+            Guid: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            Guid: string;
+        }, {
+            Guid: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        Status: string;
+        Result: {
+            Guid: string;
+        }[];
+    }, {
+        Status: string;
+        Result: {
+            Guid: string;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    Rsp: {
+        Status: string;
+        Result: {
+            Guid: string;
+        }[];
+    };
+}, {
+    Rsp: {
+        Status: string;
+        Result: {
+            Guid: string;
+        }[];
+    };
+}>;
+export type TCameraGuidsResponse = z.infer<typeof cameraGuidsResponseSchema>;
+declare const connectionResponseSchema: z.ZodObject<{
+    Rsp: z.ZodObject<{
+        Status: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        Status: string;
+    }, {
+        Status: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    Rsp: {
+        Status: string;
+    };
+}, {
+    Rsp: {
+        Status: string;
+    };
+}>;
+export type TConnectionResponse = z.infer<typeof connectionResponseSchema>;
+export declare const cameraDetailSchema: z.ZodObject<{
+    Guid: z.ZodOptional<z.ZodString>;
+    Name: z.ZodOptional<z.ZodString>;
+    EntityType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    Name?: string | undefined;
+    Guid?: string | undefined;
+    EntityType?: string | undefined;
+}, {
+    Name?: string | undefined;
+    Guid?: string | undefined;
+    EntityType?: string | undefined;
+}>;
+export declare const cameraDetailsResponseSchema: z.ZodObject<{
+    Rsp: z.ZodObject<{
+        Status: z.ZodString;
+        Result: z.ZodUnion<[z.ZodArray<z.ZodObject<{
+            Guid: z.ZodOptional<z.ZodString>;
+            Name: z.ZodOptional<z.ZodString>;
+            EntityType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }, {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }>, "many">, z.ZodObject<{
+            Guid: z.ZodOptional<z.ZodString>;
+            Name: z.ZodOptional<z.ZodString>;
+            EntityType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }, {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        Status: string;
+        Result: {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        } | {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }[];
+    }, {
+        Status: string;
+        Result: {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        } | {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    Rsp: {
+        Status: string;
+        Result: {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        } | {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }[];
+    };
+}, {
+    Rsp: {
+        Status: string;
+        Result: {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        } | {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }[];
+    };
+}>;
+export type TCameraDetailsResponse = z.infer<typeof cameraDetailsResponseSchema>;
+export type TCameraDetail = z.infer<typeof cameraDetailSchema>;
+export type TParams = Array<'Guid' | 'Name' | 'EntityType'>;
+export type GenetecAgentOptions = {
+    protocol?: 'http' | 'https' | 'https_insecure';
+    ip?: string;
+    port?: number;
+    base_uri?: string;
+    user?: string;
+    pass?: string;
+    app_id?: string;
+};
+export declare class GenetecAgent {
+    private settings;
+    private baseUrl;
+    private credentials;
+    constructor(options?: GenetecAgentOptions);
+    checkConnection(): Promise<TConnectionResponse>;
+    getAllCameraGuids(): Promise<TCameraGuidsResponse>;
+    getCameraDetails(guids: {
+        Guid: string;
+    }[], parameters: TParams): Promise<TCameraDetail[]>;
+    sendBookmark(guids: string[], bookmarkText: string): Promise<Response>;
+    private getRequestOptions;
+    private getTimeStamp;
+}
+export {};

package/esm/index.d.ts

@@ -0,0 +1,11 @@
+export * from './internal/common';
+export * from './internal/constants';
+export * from './internal/utils';
+export * from './internal/versionCompare';
+export * from './types/common';
+export { CamSwitcherAPI } from './CamSwitcherAPI';
+export { CamSwitcherEvents } from './CamSwitcherEvents';
+export { VapixAPI } from './VapixAPI';
+export * from './types/CamSwitcherEvents';
+export * from './types/CamSwitcherAPI';
+export * from './types/VapixAPI';

package/esm/index.js

@@ -0,0 +1,11 @@
+export * from './internal/common';
+export * from './internal/constants';
+export * from './internal/utils';
+export * from './internal/versionCompare';
+export * from './types/common';
+export { CamSwitcherAPI } from './CamSwitcherAPI';
+export { CamSwitcherEvents } from './CamSwitcherEvents';
+export { VapixAPI } from './VapixAPI';
+export * from './types/CamSwitcherEvents';
+export * from './types/CamSwitcherAPI';
+export * from './types/VapixAPI';

package/esm/internal/Digest.d.ts

@@ -0,0 +1,4 @@
+export declare class Digest {
+    private nonceCount;
+    getAuthHeader(user: string, pass: string, method: string, uri: string, wwwAuthenticateHeader: string): string;
+}

package/esm/internal/ProxyClient.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { IClient, TParameters } from './common';
+import { TProxyParam } from '../types/common';
+export declare class ProxyClient<Client extends IClient = IClient> {
+    client: Client;
+    getProxyUrl: () => string;
+    constructor(client: Client, getProxyUrl: () => string);
+    get: (proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<import("./common").TResponse>;
+    post: (proxy: TProxyParam, path: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<import("./common").TResponse>;
+    private getReal;
+}

package/esm/internal/common.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+type Options = {
+    ip?: string;
+    port?: number;
+    user?: string;
+    pass?: string;
+    tls?: boolean;
+    tlsInsecure?: boolean;
+};
+export type HttpOptions = Options & {
+    keepAlive?: boolean;
+};
+export type WsOptions = Options;
+export type TResponse = {
+    ok: boolean;
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+    status: number;
+    body: any | null;
+};
+export type TParameters = Record<string, string | number | boolean | null | undefined>;
+export type TGetFunction = (url: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<TResponse>;
+export type TPostFunction = (url: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<TResponse>;
+export interface IClient {
+    get: TGetFunction;
+    post: TPostFunction;
+}
+export interface IWebsocket<Event extends {
+    readonly data: string;
+}> {
+    destroy: () => void;
+    onmessage: null | ((event: Event) => void);
+    send: (data: string) => void;
+}
+export declare function isClient(arg?: Options | IClient): arg is IClient;
+export declare function responseStringify(res: TResponse): Promise<string>;
+export declare function pad(num: number, size: number): string;
+export declare function isNullish<T>(value: T | undefined | null): value is undefined | null;
+export {};

package/{internal → esm/internal}/common.js

@@ -1,9 +1,6 @@
 export function isClient(arg = {}) {
     return 'get' in arg && 'post' in arg;
 }
-export function isBrowserEnvironment() {
-    return typeof process === 'undefined' || !process.versions.node;
-}
 export async function responseStringify(res) {
     return JSON.stringify({
         status: res.status,

package/esm/internal/constants.d.ts

@@ -0,0 +1 @@
+export declare const FIRMWARE_WITH_BITRATE_MODES_SUPPORT = "11.11.73";

package/esm/internal/transformers.d.ts

@@ -0,0 +1,5 @@
+import type { CamelCasedProperties, CamelCasedPropertiesDeep, SnakeCasedProperties, SnakeCasedPropertiesDeep } from 'type-fest';
+export declare const toCamelCase: <T extends object>(o: T) => CamelCasedProperties<T>;
+export declare const toCamelCaseDeep: <T extends object>(o: T) => CamelCasedPropertiesDeep<T>;
+export declare const toSnakeCase: <T extends object>(o: T) => SnakeCasedProperties<T>;
+export declare const toSnakeCaseDeep: <T extends object>(o: T) => SnakeCasedPropertiesDeep<T>;

package/esm/internal/utils.d.ts

@@ -0,0 +1,11 @@
+import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
+import { TParameters } from './common';
+export declare const addParametersToPath: (path: string, params?: TParameters) => string;
+export declare const paramToUrl: (params?: TParameters) => string;
+export declare const arrayToUrl: (arr: string | string[]) => string;
+export declare const isCamera: (id?: string) => boolean;
+export declare const isStream: (id?: string) => boolean;
+export declare const isClip: (id?: string) => boolean;
+export declare const isTracker: (id?: string) => boolean;
+export declare const isPlaylist: (id?: string) => boolean;
+export declare const isLoopPlayType: (playType: TPlaylistPlayType) => boolean;

package/esm/internal/versionCompare.d.ts

@@ -0,0 +1,6 @@
+export declare const assertVersionString: (s: string, msg?: string) => void;
+export declare const isFirmwareVersionAtLeast: (version: string, compareVersion: string) => boolean;
+export declare const isVersionAtLeast: (version: string, compareVersion: string) => boolean;
+export declare const firmwareVersionCompare: (a: string, b: string) => 1 | -1 | 0;
+export declare const versionCompare: (a: string, b: string) => 1 | -1 | 0;
+export declare const fixVersionToDots: (version: string) => string;

package/esm/node/DefaultClient.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IClient, HttpOptions, TParameters } from '../internal/common';
+export declare class DefaultClient implements IClient {
+    private tls;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private httpRequestSender;
+    constructor(opt?: HttpOptions);
+    get url(): string;
+    get(path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
+    post(path: string, data: string | FormData | Buffer, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
+    private getBaseConnectionParams;
+}

package/esm/node/HttpRequestSender.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
+export type HttpRequestOptions = {
+    method?: string;
+    protocol: string;
+    host: string;
+    port: number;
+    path: string;
+    user?: string;
+    pass?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+};
+export type AgentOptions = {
+    rejectUnaurhorized?: boolean;
+    keepAlive?: boolean;
+};
+export declare class HttpRequestSender {
+    private agent?;
+    private authData?;
+    constructor(agentOptions?: AgentOptions);
+    sendRequest(options: HttpRequestOptions, postData?: Buffer | string | UndiciFormData): Promise<UndiciResponse>;
+    private sendRequestWithAuth;
+    private static getURL;
+    private getAuthorization;
+    private invalidateAuthorization;
+    private static getAuthHeader;
+}

package/esm/node/HttpServer.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import * as EventEmitter from 'events';
+export type HttpServerOptions = {
+    host?: string;
+    port?: number;
+};
+type TOnRequestCallback = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare class HttpServer extends EventEmitter {
+    private host;
+    private port;
+    private registeredPaths;
+    private server;
+    private sockets;
+    constructor(options?: HttpServerOptions);
+    getServer(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    onRequest(pathName: string, callback: TOnRequestCallback): void;
+    close(): void;
+}
+export {};

package/esm/node/WsClient.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from '../internal/common';
+export type WsClientOptions = WsOptions & {
+    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 {
+    private user;
+    private pass;
+    private address;
+    private protocol?;
+    private pingInterval;
+    private wsOptions;
+    private digestAddress;
+    private isAlive;
+    private pingTimer?;
+    private ws?;
+    private isClosed;
+    constructor(options: WsClientOptions);
+    open(wwwAuthenticateHeader?: string): void;
+    send(data: Buffer | string): void;
+    close(): void;
+    reconnect(): void;
+    private closeWsConnection;
+}

package/esm/node/WsEventClient.d.ts

@@ -0,0 +1,13 @@
+import { IWebsocket } from '../internal/common';
+import { WsClientOptions } from './WsClient';
+type TEvent = {
+    data: string;
+};
+export declare class WsEventClient implements IWebsocket<TEvent> {
+    private wsClient;
+    constructor(options: WsClientOptions);
+    send: (data: string) => void;
+    destroy: () => void;
+    onmessage: ((event: TEvent) => void) | null;
+}
+export {};

package/esm/node/index.d.ts

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';

package/esm/node/index.js

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';