camstreamerlib 4.0.0-beta.13 → 4.0.0-beta.130

package/esm/CamSwitcherEvents.d.ts

@@ -1,18 +0,0 @@
-import { IWebsocket } from './internal/types';
-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/esm/VapixAPI.d.ts

@@ -1,78 +0,0 @@
-import { IClient, TParameters, TResponse } from './internal/types';
-import { 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<TResponse> = IClient<TResponse>> {
-    client: ProxyClient<Client>;
-    constructor(client: Client, getProxyUrl: () => string);
-    getUrlEncoded(proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
-    postJson(proxy: TProxyParam, 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<{
-        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | null;
-        Name: string;
-        NiceName: string;
-        Vendor: string;
-        Version: string;
-        License: string;
-        Status: string;
-        ApplicationID?: string | undefined;
-        ConfigurationPage?: string | undefined;
-        VendorHomePage?: string | undefined;
-        LicenseName?: string | undefined;
-    }[]>;
-    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

@@ -1,43 +0,0 @@
-import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { WsOptions } from './internal/types';
-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

@@ -1,37 +0,0 @@
-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 declare class PtzNotSupportedError extends Error {
-    constructor();
-}
-export {};

package/esm/events/AxisCameraStationEvents.d.ts

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

package/esm/events/GenetecAgent.js

@@ -1,119 +0,0 @@
-import { z } from 'zod';
-import { responseStringify, pad } from '../internal/utils';
-const ACTION = 'AddCameraBookmark';
-const GET_CAMERAS_URL = 'report/EntityConfiguration?q=EntityTypes@Camera';
-const GET_CAMERAS_DETAILS_URL = '/entity?q=';
-const cameraGuidsResponseSchema = z.object({
-    Rsp: z.object({
-        Status: z.string(),
-        Result: z.array(z.object({ Guid: z.string() })),
-    }),
-});
-const connectionResponseSchema = z.object({
-    Rsp: z.object({
-        Status: z.string(),
-    }),
-});
-export const cameraDetailSchema = z.object({
-    Guid: z.string().optional(),
-    Name: z.string().optional(),
-    EntityType: z.string().optional(),
-});
-export const cameraDetailsResponseSchema = z.object({
-    Rsp: z.object({
-        Status: z.string(),
-        Result: z.union([z.array(cameraDetailSchema), cameraDetailSchema]),
-    }),
-});
-export class GenetecAgent {
-    settings;
-    baseUrl;
-    credentials;
-    constructor(options = {}) {
-        this.settings = {
-            protocol: options.protocol ?? 'http',
-            ip: options.ip ?? '127.0.0.1',
-            port: options.port ?? 80,
-            base_uri: options.base_uri ?? 'WebSdk',
-            user: options.user ?? 'root',
-            pass: options.pass ?? '',
-            app_id: options.app_id ?? '',
-        };
-        this.baseUrl = `${this.settings.protocol}://${this.settings.ip}:${this.settings.port}/${this.settings.base_uri}`;
-        this.credentials = btoa(`${this.settings.user};${this.settings.app_id}:${this.settings.pass}`);
-    }
-    async checkConnection() {
-        const requestOptions = this.getRequestOptions('GET');
-        const res = await fetch(`${this.baseUrl}/`, requestOptions);
-        if (!res.ok) {
-            throw new Error(await responseStringify(res));
-        }
-        return connectionResponseSchema.parse(await res.json());
-    }
-    async getAllCameraGuids() {
-        const requestOptions = this.getRequestOptions('GET');
-        const res = await fetch(`${this.baseUrl}/${GET_CAMERAS_URL}`, requestOptions);
-        if (!res.ok) {
-            throw new Error(await responseStringify(res));
-        }
-        return cameraGuidsResponseSchema.parse(await res.json());
-    }
-    async getCameraDetails(guids, parameters) {
-        const params = parameters.join(',');
-        let camerasGuids = [];
-        const requestOptions = this.getRequestOptions('GET');
-        const allCameras = [];
-        const chunkSize = 10;
-        while (guids.length > 0) {
-            const chunk = guids.slice(0, chunkSize);
-            guids.splice(0, chunkSize);
-            camerasGuids = chunk.map((item) => item.Guid);
-            const camerasDetailsUrl = [];
-            for (const guid of camerasGuids) {
-                camerasDetailsUrl.push(`entity=${guid},${params}`);
-            }
-            const res = await fetch(`${this.baseUrl}/${GET_CAMERAS_DETAILS_URL}${camerasDetailsUrl.join(',')}`, requestOptions);
-            if (!res.ok) {
-                throw new Error(await responseStringify(res));
-            }
-            const data = cameraDetailsResponseSchema.parse(await res.json());
-            const resultArray = Array.isArray(data.Rsp.Result) ? data.Rsp.Result : [data.Rsp.Result];
-            allCameras.push(...resultArray);
-        }
-        return allCameras;
-    }
-    async sendBookmark(guids, bookmarkText) {
-        const cameraEntitiesUrl = [];
-        const timeStamp = this.getTimeStamp();
-        const requestOptions = this.getRequestOptions('POST');
-        for (const guid of guids) {
-            cameraEntitiesUrl.push(`${ACTION}(${guid},${timeStamp},${bookmarkText})`);
-        }
-        const res = await fetch(`${this.baseUrl}/action?q=${cameraEntitiesUrl.join(',')}`, requestOptions);
-        if (!res.ok) {
-            throw new Error(await responseStringify(res));
-        }
-        return res;
-    }
-    getRequestOptions(method) {
-        return {
-            method,
-            headers: new Headers({
-                Authorization: `Basic ${this.credentials}`,
-                Accept: 'text/json',
-            }),
-            redirect: 'follow',
-        };
-    }
-    getTimeStamp() {
-        const date = new Date();
-        const year = date.getUTCFullYear();
-        const month = pad(date.getUTCMonth() + 1, 2);
-        const day = pad(date.getUTCDate(), 2);
-        const hours = pad(date.getUTCHours(), 2);
-        const minutes = pad(date.getUTCMinutes(), 2);
-        const seconds = pad(date.getUTCSeconds(), 2);
-        const miliSeconds = pad(date.getUTCMilliseconds(), 2);
-        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${miliSeconds}Z`;
-    }
-}

package/esm/index.d.ts

@@ -1,16 +0,0 @@
-export * from './internal/types';
-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 { CamOverlayAPI } from './CamOverlayAPI';
-export { CamScripterAPI } from './CamScripterAPI';
-export { CamStreamerAPI } from './CamStreamerAPI';
-export * from './types/CamSwitcherEvents';
-export * from './types/CamSwitcherAPI';
-export * from './types/VapixAPI';
-export * from './types/CamOverlayAPI';
-export * from './models/CamOverlayAPI';

package/esm/internal/ProxyClient.d.ts

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

package/esm/internal/types.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-import { Response as UndiciResponse } from 'undici';
-export 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 TParameters = Record<string, string | number | boolean | null | undefined>;
-export type TResponse = Response | UndiciResponse;
-export type TGetParams = [url: string, parameters?: TParameters, headers?: Record<string, string>];
-export type TPostParams = [
-    url: string,
-    data: string | Buffer | FormData,
-    parameters?: TParameters,
-    headers?: Record<string, string>
-];
-export interface IClient<TRes extends TResponse> {
-    get: (...params: TGetParams) => Promise<TRes>;
-    post: (...params: TPostParams) => Promise<TRes>;
-}
-export type TBlobResponse<Client extends IClient<TResponse>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
-export interface IWebsocket<Event extends {
-    readonly data: string;
-}> {
-    destroy: () => void;
-    onmessage: null | ((event: Event) => void);
-    send: (data: string) => void;
-}

package/esm/models/CamOverlayAPI/constants.d.ts

@@ -1,11 +0,0 @@
-export declare const allowedWidgetNames: {
-    readonly accuweather: "accuweather";
-    readonly infoticker: "infoticker";
-    readonly customGraphics: "customGraphics";
-    readonly ptzCompass: "ptzCompass";
-    readonly images: "images";
-    readonly ptz: "ptz";
-    readonly pip: "pip";
-    readonly screenSharing: "screenSharing";
-    readonly web_camera: "web_camera";
-};

package/esm/models/CamOverlayAPI/constants.js

@@ -1,11 +0,0 @@
-export const allowedWidgetNames = {
-    accuweather: 'accuweather',
-    infoticker: 'infoticker',
-    customGraphics: 'customGraphics',
-    ptzCompass: 'ptzCompass',
-    images: 'images',
-    ptz: 'ptz',
-    pip: 'pip',
-    screenSharing: 'screenSharing',
-    web_camera: 'web_camera',
-};

package/esm/models/CamOverlayAPI/fileSchema.d.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-export declare const storageSchema: z.ZodUnion<[z.ZodLiteral<"flash">, z.ZodLiteral<"SD0">, z.ZodLiteral<"ftp">, z.ZodLiteral<"samba">, z.ZodLiteral<"url">]>;
-export declare const fileSchema: z.ZodObject<{
-    name: z.ZodString;
-    path: z.ZodString;
-    storage: z.ZodUnion<[z.ZodLiteral<"flash">, z.ZodLiteral<"SD0">, z.ZodLiteral<"ftp">, z.ZodLiteral<"samba">, z.ZodLiteral<"url">]>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    name: string;
-    storage: "url" | "flash" | "SD0" | "ftp" | "samba";
-}, {
-    path: string;
-    name: string;
-    storage: "url" | "flash" | "SD0" | "ftp" | "samba";
-}>;
-export declare const fileListSchema: z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
-    path: z.ZodString;
-    storage: z.ZodUnion<[z.ZodLiteral<"flash">, z.ZodLiteral<"SD0">, z.ZodLiteral<"ftp">, z.ZodLiteral<"samba">, z.ZodLiteral<"url">]>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    name: string;
-    storage: "url" | "flash" | "SD0" | "ftp" | "samba";
-}, {
-    path: string;
-    name: string;
-    storage: "url" | "flash" | "SD0" | "ftp" | "samba";
-}>, "many">;

package/esm/models/CamOverlayAPI/fileSchema.js

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-export const storageSchema = z.union([
-    z.literal('flash'),
-    z.literal('SD0'),
-    z.literal('ftp'),
-    z.literal('samba'),
-    z.literal('url'),
-]);
-export const fileSchema = z.object({
-    name: z.string(),
-    path: z.string().url(),
-    storage: storageSchema,
-});
-export const fileListSchema = z.array(fileSchema);

package/esm/models/CamOverlayAPI/imagesSchema.js

@@ -1,7 +0,0 @@
-import { allowedWidgetNames } from './constants';
-import { overlaySchema, widgetCommonSchema } from './widgetCommonSchema';
-import { z } from 'zod';
-export const imagesSchema = widgetCommonSchema.extend({
-    name: z.literal(allowedWidgetNames.images),
-    overlayList: z.array(overlaySchema),
-});

package/esm/models/CamOverlayAPI/ptzSchema.js

@@ -1,10 +0,0 @@
-import { allowedWidgetNames } from './constants';
-import { overlaySchema, widgetCommonSchema } from './widgetCommonSchema';
-import { z } from 'zod';
-export const ptzSchema = widgetCommonSchema.extend({
-    name: z.literal(allowedWidgetNames.ptz),
-    ptz_positions: z.record(z.string(), z.object({
-        overlayList: z.array(overlaySchema.omit({ active: true, fps: true })),
-        loop: z.boolean(),
-    })),
-});

package/esm/models/CamOverlayAPI/screenSharingSchema.js

@@ -1,6 +0,0 @@
-import { allowedWidgetNames } from './constants';
-import { sharingSchema } from './widgetCommonSchema';
-import { z } from 'zod';
-export const screenSharingSchema = sharingSchema.extend({
-    name: z.literal(allowedWidgetNames.screenSharing),
-});

package/esm/models/CamOverlayAPI/webCameraSharingSchema.js

@@ -1,6 +0,0 @@
-import { allowedWidgetNames } from './constants';
-import { sharingSchema } from './widgetCommonSchema';
-import { z } from 'zod';
-export const webCameraSharingSchema = sharingSchema.extend({
-    name: z.literal(allowedWidgetNames.web_camera),
-});

package/esm/models/CamOverlayAPI/widgetsSchema.js

@@ -1,24 +0,0 @@
-import { customGraphicsSchema } from './customGraphicsSchema';
-import { imagesSchema } from './imagesSchema';
-import { accuweatherSchema } from './accuweatherSchema';
-import { infoTickerSchema } from './infotickerSchema';
-import { pipSchema } from './pipSchema';
-import { ptzCompassSchema } from './ptzCompassSchema';
-import { ptzSchema } from './ptzSchema';
-import { screenSharingSchema } from './screenSharingSchema';
-import { webCameraSharingSchema } from './webCameraSharingSchema';
-import { z } from 'zod';
-export const widgetsSchema = z.discriminatedUnion('name', [
-    infoTickerSchema,
-    accuweatherSchema,
-    ptzCompassSchema,
-    imagesSchema,
-    ptzSchema,
-    pipSchema,
-    customGraphicsSchema,
-    screenSharingSchema,
-    webCameraSharingSchema,
-]);
-export const widgetListSchema = z.object({
-    services: z.array(widgetsSchema),
-});

package/esm/node/DefaultClient.d.ts

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

package/esm/node/WsClient.d.ts

@@ -1,39 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import * as EventEmitter from 'events';
-import { WsOptions } from '../internal/types';
-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

@@ -1,13 +0,0 @@
-import { IWebsocket } from '../internal/types';
-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/WsEventClient.js

@@ -1,18 +0,0 @@
-import { WsClient } from './WsClient';
-export class WsEventClient {
-    wsClient;
-    constructor(options) {
-        this.wsClient = new WsClient(options);
-        this.wsClient.on('message', (data) => {
-            this.onmessage?.({ data: data.toString() });
-        });
-    }
-    send = (data) => {
-        this.wsClient.send(data);
-    };
-    destroy = () => {
-        this.wsClient.close();
-        this.onmessage = null;
-    };
-    onmessage = null;
-}