camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.4

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

@@ -11,7 +11,7 @@ export class VapixAPI {
     constructor(client, getProxyUrl) {
         this.client = new ProxyClient(client, getProxyUrl);
     }
-    async getUrlEncoded(proxy = null, path, parameters, headers = {}) {
+    async getUrlEncoded(proxy, path, parameters, headers = {}) {
         const data = paramToUrl(parameters);
         const head = { ...headers, 'Content-Type': 'application/x-www-form-urlencoded' };
         const res = await this.client.post(proxy, path, data, {}, head);
@@ -20,7 +20,7 @@ export class VapixAPI {
         }
         return res;
     }
-    async postJson(proxy = null, path, jsonData, headers = {}) {
+    async postJson(proxy, path, jsonData, headers = {}) {
         const data = JSON.stringify(jsonData);
         const head = { ...headers, 'Content-Type': 'application/json' };
         const res = await this.client.post(proxy, path, data, {}, head);
@@ -231,9 +231,9 @@ export class VapixAPI {
                 const gTour = {
                     id: gTourBaseName,
                     camNbr: response[gTourBaseName + '.CamNbr'],
-                    name: response[gTourBaseName + '.Name'],
+                    name: response[gTourBaseName + '.Name'] ?? 'Guard Tour ' + (i + 1),
                     randomEnabled: response[gTourBaseName + '.RandomEnabled'],
-                    running: response[gTourBaseName + '.Running'],
+                    running: response[gTourBaseName + '.Running'] ?? 'no',
                     timeBetweenSequences: response[gTourBaseName + '.TimeBetweenSequences'],
                     tour: [],
                 };
@@ -298,8 +298,12 @@ export class VapixAPI {
         });
         const data = parseCameraPtzResponse(await response.text());
         const res = {};
-        Object.keys(data).forEach((camera) => {
-            res[Number(camera) - 1] = data[Number(camera)].map(({ data: itemData, ...d }) => d);
+        Object.keys(data)
+            .map(Number)
+            .forEach((camera) => {
+            if (data[camera] !== undefined) {
+                res[camera - 1] = data[camera]?.map(({ data: itemData, ...d }) => d);
+            }
         });
         return res;
     }
@@ -323,7 +327,7 @@ export class VapixAPI {
     }
     async getInputState(port, proxy = null) {
         const response = await (await this.getUrlEncoded(proxy, '/axis-cgi/io/port.cgi', { checkactive: port.toString() })).text();
-        return response.split('=')[1].indexOf('active') === 0;
+        return response.split('=')[1]?.indexOf('active') === 0;
     }
     async setOutputState(port, active, proxy = null) {
         return this.getUrlEncoded(proxy, '/axis-cgi/io/port.cgi', { action: active ? `${port}:/` : `${port}:\\` });
@@ -333,10 +337,10 @@ export class VapixAPI {
         const xml = await res.text();
         const result = (await parseStringPromise(xml));
         const apps = [];
-        for (let i = 0; i < result.reply.application.length; i++) {
+        for (const app of result.reply.application) {
             apps.push({
-                ...result.reply.application[i].$,
-                appId: APP_IDS.find((id) => id.toLowerCase() === result.reply.application[i].$.Name.toLowerCase()) ?? null,
+                ...app.$,
+                appId: APP_IDS.find((id) => id.toLowerCase() === app.$.Name.toLowerCase()) ?? null,
             });
         }
         return apps;
@@ -389,14 +393,14 @@ export class VapixAPI {
 const parseParameters = (response) => {
     const params = {};
     const lines = response.split(/[\r\n]/);
-    for (let i = 0; i < lines.length; i++) {
-        if (lines[i].length === 0 || lines[i].substring(0, 7) === '# Error') {
+    for (const line of lines) {
+        if (line.length === 0 || line.substring(0, 7) === '# Error') {
             continue;
         }
-        const delimiterPos = lines[i].indexOf('=');
+        const delimiterPos = line.indexOf('=');
         if (delimiterPos !== -1) {
-            const paramName = lines[i].substring(0, delimiterPos);
-            const paramValue = lines[i].substring(delimiterPos + 1);
+            const paramName = line.substring(0, delimiterPos);
+            const paramValue = line.substring(delimiterPos + 1);
             params[paramName] = paramValue;
         }
     }
@@ -442,7 +446,7 @@ const parsePtz = (parsed) => {
         };
         res.push({
             id,
-            name: data[0],
+            name: data[0] ?? 'Preset ' + id,
             data: {
                 pan: getValue('pan'),
                 tilt: getValue('tilt'),

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/{VapixEvents.js → esm/VapixEvents.js}

@@ -39,10 +39,10 @@ export class VapixEvents extends EventEmitter {
         this.ws.on('open', () => {
             const topics = [];
             const eventNames = this.eventNames();
-            for (let i = 0; i < eventNames.length; i++) {
-                if (!this.isReservedEventName(eventNames[i])) {
+            for (const eventName of eventNames) {
+                if (!this.isReservedEventName(eventName)) {
                     const topic = {
-                        topicFilter: eventNames[i],
+                        topicFilter: eventName,
                     };
                     topics.push(topic);
                 }

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/{internal → esm/internal}/Digest.js

@@ -4,17 +4,17 @@ export class Digest {
     getAuthHeader(user, pass, method, uri, wwwAuthenticateHeader) {
         const digestItems = {};
         const digestArr = wwwAuthenticateHeader.substring(wwwAuthenticateHeader.indexOf('Digest') + 6).split(',');
-        for (let i = 0; i < digestArr.length; i++) {
-            const pos = digestArr[i].indexOf('=');
-            const key = digestArr[i].substring(0, pos).trim();
-            const value = digestArr[i].substring(pos + 1).trim();
+        for (const arg of digestArr) {
+            const pos = arg.indexOf('=');
+            const key = arg.substring(0, pos).trim();
+            const value = arg.substring(pos + 1).trim();
             digestItems[key] = value.replace(/"/g, '');
         }
         const HA1 = crypto.createHash('md5').update(`${user}:${digestItems['realm']}:${pass}`).digest('hex');
         const HA2 = crypto.createHash('md5').update(`${method}:${uri}`).digest('hex');
         const ncValue = ('00000000' + this.nonceCount.toString(16)).slice(-8);
         let response;
-        if (digestItems['qop']) {
+        if (digestItems['qop'] !== undefined) {
             response = crypto
                 .createHash('md5')
                 .update(`${HA1}:${digestItems['nonce']}:${ncValue}:162d50aa594e9648:auth:${HA2}`)
@@ -29,7 +29,7 @@ export class Digest {
             `nonce="${digestItems['nonce']}",` +
             `uri="${uri}",` +
             `response="${response}"`;
-        if (digestItems['qop']) {
+        if (digestItems['qop'] !== undefined) {
             header += `,qop=auth,nc=${ncValue},cnonce="162d50aa594e9648"`;
         }
         this.nonceCount++;

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/{node → esm/node}/DefaultClient.js

@@ -36,7 +36,7 @@ export class DefaultClient {
         return this.httpRequestSender.sendRequest(options, data);
     }
     getBaseConnectionParams(method, path, params) {
-        let pathName = addParametersToPath(path, params);
+        const pathName = addParametersToPath(path, params);
         return {
             method: method,
             protocol: this.tls ? 'https:' : 'http:',

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/{node → esm/node}/HttpServer.js

@@ -86,7 +86,7 @@ export class HttpServer extends EventEmitter {
     close() {
         this.server.close();
         for (const key in this.sockets) {
-            this.sockets[key].destroy();
+            this.sockets[key]?.destroy();
         }
     }
 }

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;
+}