camstreamerlib 4.0.0-beta.32 → 4.0.0-beta.34

package/esm/CamOverlayAPI.d.ts

@@ -1,41 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IClient, TBlobResponse, TResponse } from './internal/types';
-import { THttpRequestOptions, TProxyParams, TNetworkCamera } from './types/common';
-import { ProxyClient } from './internal/ProxyClient';
-import { ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TStorage, TStorageDataList, TWidget } from './types/CamOverlayAPI';
-export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
-    private client;
-    constructor(client: Client);
-    static getBasePath: () => string;
-    static getProxyPath: () => string;
-    static getFilePreviewPath: (path: string) => string;
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
-    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
-    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
-    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
-    getMjpegStreamImage(mjpegUrl: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
-    listFiles(fileType: TFileType, options?: THttpRequestOptions): Promise<TFileList>;
-    uploadFile(fileType: TFileType, formData: FormData, storage: TStorage, options?: THttpRequestOptions): Promise<void>;
-    removeFile(fileType: TFileType, fileParams: TFile, options?: THttpRequestOptions): Promise<void>;
-    getFileStorage(fileType: TFileType, options?: THttpRequestOptions): Promise<TStorageDataList>;
-    getFilePreviewFromCamera(path: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
-    updateInfoticker(serviceId: number, text: string, options?: THttpRequestOptions): Promise<void>;
-    setEnabled(serviceId: number, enabled: boolean, options?: THttpRequestOptions): Promise<void>;
-    isEnabled(serviceId: number, options?: THttpRequestOptions): Promise<boolean>;
-    getSingleWidget(serviceId: number, options?: THttpRequestOptions): Promise<TWidget>;
-    getWidgets(options?: THttpRequestOptions): Promise<TWidget[]>;
-    updateSingleWidget(widget: TWidget, options?: THttpRequestOptions): Promise<void>;
-    updateWidgets(widgets: TWidget[], options?: THttpRequestOptions): Promise<void>;
-    updateCGText(serviceId: number, fields: TField[], options?: THttpRequestOptions): Promise<void>;
-    updateCGImagePos(serviceId: number, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
-    updateCGImage(serviceId: number, path: string, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
-    updateCGImageFromData(serviceId: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
-    private promiseCGUpdate;
-    private _get;
-    private _post;
-    private _getBlob;
-    private parseBlobResponse;
-    private _postUrlEncoded;
-    private _postJsonEncoded;
-}

package/esm/CamOverlayDrawingAPI.d.ts

@@ -1,41 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import * as EventEmitter from 'events';
-import { CamOverlayDrawingOptions, TCairoCreateResponse, TCairoResponse, TUploadImageResponse, TWriteTextParams } from './types/CamOverlayDrawingAPI';
-export declare class CamOverlayDrawingAPI extends EventEmitter {
-    private tls;
-    private tlsInsecure;
-    private ip;
-    private port;
-    private user;
-    private pass;
-    private cameraList;
-    private zIndex;
-    private callId;
-    private sendMessages;
-    private timeoutCheckTimer;
-    private wsConnected;
-    private ws;
-    constructor(options?: CamOverlayDrawingOptions);
-    connect(): void;
-    disconnect(): void;
-    isConnected(): boolean;
-    cairo(command: string, ...params: unknown[]): Promise<TCairoResponse | TCairoCreateResponse>;
-    writeText(...params: TWriteTextParams): Promise<TCairoResponse>;
-    uploadImageData(imgBuffer: Buffer): Promise<TUploadImageResponse>;
-    uploadFontData(fontBuffer: Buffer): Promise<TCairoCreateResponse>;
-    showCairoImage(cairoImage: string, posX: number, posY: number): Promise<TCairoResponse>;
-    showCairoImageAbsolute(cairoImage: string, posX: number, posY: number, width: number, height: number): Promise<TCairoResponse>;
-    removeImage(): Promise<TCairoResponse>;
-    private createWsClient;
-    private incomingWsMessageHandler;
-    private sendMessage;
-    private sendBinaryMessage;
-    private startMsgsTimeoutCheck;
-    private stopMsgsTimeoutCheck;
-    private reconnectWithError;
-    private reportMessage;
-    private reportError;
-    private reportClose;
-}

package/esm/CamOverlayPainter/Frame.d.ts

@@ -1,67 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import { TAlign, TCairoCreateResponse, TUploadImageResponse } from '../types/CamOverlayDrawingAPI';
-import { ResourceManager } from './ResourceManager';
-import { TBg, TBorder, TDrawingCallback, TFrame, TFrameOptions, TObjectFitType, TRgb, TRgba, TText, TTmf } from '../types/CamOverlayPainter';
-export declare class Frame extends EventEmitter {
-    protected enabled: boolean;
-    protected posX: number;
-    protected posY: number;
-    protected width: number;
-    protected height: number;
-    private text;
-    private fontColor;
-    private fontName?;
-    private font?;
-    private align;
-    private textType;
-    private bgColor?;
-    private bgImageName?;
-    private bgImage?;
-    private bgType?;
-    private borderRadius;
-    private borderWidth;
-    private borderColor;
-    private customDraw?;
-    private layer;
-    protected children: Frame[];
-    constructor(opt: TFrameOptions);
-    enable(): void;
-    disable(): void;
-    setFramePosition(x: number, y: number): void;
-    setFrameSize(width: number, height: number): void;
-    getFrameInfo(): TFrame;
-    setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
-    setFontColor(fontColor: TRgb): void;
-    setFont(fontName: string): void;
-    setFontData(fontData: TCairoCreateResponse): void;
-    getTextInfo(): TText;
-    setBgColor(color: TRgba): void;
-    setBgImage(imageName: string, type?: TObjectFitType): void;
-    setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
-    setBgType(type: TObjectFitType): void;
-    getBgInfo(): TBg;
-    setBorderRadius(radius: number): void;
-    setBorderWidth(width: number): void;
-    setBorderColor(color: TRgba): void;
-    getBorderInfo(): TBorder;
-    setCustomDraw(customDraw: TDrawingCallback): void;
-    resetFont(): void;
-    resetBgColor(): void;
-    resetBgImage(): void;
-    resetCustomDraw(): void;
-    clear(): void;
-    insert(...frames: Frame[]): void;
-    getLayers(): Set<number>;
-    protected layoutChanged(): void;
-    displayImage(cod: CamOverlayDrawingAPI, resourceManager: ResourceManager, cairo: string, ppX: number, ppY: number, scale: number, layer: number): Promise<void>;
-    private prepareResources;
-    protected displayOwnImage(cod: CamOverlayDrawingAPI, cairo: string, ppX: number, ppY: number, scale: number): Promise<void>;
-    private clipDrawing;
-    private drawFrame;
-    private drawImage;
-    private drawText;
-    private drawBorder;
-    private drawRectPath;
-}

package/esm/CamOverlayPainter/Painter.d.ts

@@ -1,43 +0,0 @@
-import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import { CamOverlayDrawingOptions } from '../types/CamOverlayDrawingAPI';
-import { ResourceManager } from './ResourceManager';
-import { Frame } from './Frame';
-import { TCoAlignment, TPainterOptions } from '../types/CamOverlayPainter';
-export declare const COORD: {
-    readonly top_left: readonly [-1, -1];
-    readonly center_left: readonly [-1, 0];
-    readonly bottom_left: readonly [-1, 1];
-    readonly top_center: readonly [0, -1];
-    readonly center: readonly [0, 0];
-    readonly bottom_center: readonly [0, 1];
-    readonly top_right: readonly [1, -1];
-    readonly center_right: readonly [1, 0];
-    readonly bottom_right: readonly [1, 1];
-};
-export declare class Painter extends Frame {
-    private screenWidth;
-    private screenHeight;
-    private coAlignment;
-    private cod;
-    private rm;
-    private refreshLayers;
-    private layers;
-    constructor(opt: TPainterOptions, coopt: CamOverlayDrawingOptions);
-    get camOverlayDrawingAPI(): CamOverlayDrawingAPI;
-    get resourceManager(): ResourceManager;
-    connect(): void;
-    disconnect(): void;
-    isConnected(): boolean;
-    registerImage(moniker: string, fileName: string): void;
-    registerFont(moniker: string, fileName: string): void;
-    setScreenSize(sw: number, sh: number): void;
-    setCoAlignment(coAlignment: TCoAlignment): void;
-    protected layoutChanged(): void;
-    display(scale?: number): Promise<void>;
-    hide(): Promise<void>;
-    invalidateLayer(layer: number): Promise<void>;
-    private prepareLayers;
-    private prepareSurface;
-    private cleanupSurface;
-    private positionConvertor;
-}

package/esm/CamOverlayPainter/ResourceManager.d.ts

@@ -1,15 +0,0 @@
-import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import { TUploadImageResponse, TCairoCreateResponse } from '../types/CamOverlayDrawingAPI';
-export declare class ResourceManager {
-    private co;
-    private imgFileNames;
-    private fontFileNames;
-    private images;
-    private fonts;
-    constructor(co: CamOverlayDrawingAPI);
-    registerImage(moniker: string, fileName: string): void;
-    registerFont(moniker: string, fileName: string): void;
-    image(moniker: string): Promise<TUploadImageResponse>;
-    font(moniker: string): Promise<TCairoCreateResponse>;
-    clear(): void;
-}

package/esm/CamScripterAPICameraEventsGenerator.d.ts

@@ -1,74 +0,0 @@
-/// <reference types="node" />
-import * as EventEmitter from 'events';
-import { WsOptions } from './internal/types';
-export type CamScripterOptions = WsOptions;
-export type TDeclaration = {
-    type?: '' | 'SOURCE' | 'DATA';
-    namespace: string;
-    key: string;
-    value: string | boolean | number;
-    value_type: 'STRING' | 'INT' | 'BOOL' | 'DOUBLE';
-    key_nice_name?: string;
-    value_nice_name?: string;
-};
-export type TEventDeclaration = {
-    declaration_id: string;
-    stateless: boolean;
-    declaration: TDeclaration[];
-};
-export type TEventUndeclaration = {
-    declaration_id: string;
-};
-export type TEventData = {
-    namespace: string;
-    key: string;
-    value: string | boolean | number;
-    value_type: 'STRING' | 'INT' | 'BOOL' | 'DOUBLE';
-};
-export type TEvent = {
-    declaration_id: string;
-    event_data: TEventData[];
-};
-export type TResponse = {
-    call_id: number;
-    message: string;
-};
-export type TErrorResponse = {
-    error: string;
-    call_id?: number;
-};
-export interface CamScripterAPICameraEventsGenerator {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'error', listener: (err: Error) => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'error', err: Error): boolean;
-}
-export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
-    private tls;
-    private tlsInsecure;
-    private ip;
-    private port;
-    private user;
-    private pass;
-    private callId;
-    private sendMessages;
-    private timeoutCheckTimer;
-    private wsConnected;
-    private ws;
-    constructor(options?: CamScripterOptions);
-    connect(): void;
-    disconnect(): void;
-    declareEvent(eventDeclaration: TEventDeclaration): Promise<TResponse>;
-    undeclareEvent(eventUndeclaration: TEventUndeclaration): Promise<TResponse>;
-    sendEvent(event: TEvent): Promise<TResponse>;
-    private createWsClient;
-    private incomingWsMessageHandler;
-    private sendMessage;
-    private startMsgsTimeoutCheck;
-    private stopMsgsTimeoutCheck;
-    private reconnectWithError;
-    private reportErr;
-    private reportClose;
-}

package/esm/CamStreamerAPI.d.ts

@@ -1,19 +0,0 @@
-import { ProxyClient } from './internal/ProxyClient';
-import { IClient, TResponse } from './internal/types';
-import { TStreamAttributes, TStreamList } from './types/CamStreamerAPI';
-import { THttpRequestOptions, TProxyParams } from './types/common';
-export declare class CamStreamerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
-    client: Client;
-    constructor(client: Client);
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
-    getStreamList(options?: THttpRequestOptions): Promise<TStreamList>;
-    getStream(streamId: string, options?: THttpRequestOptions): Promise<TStreamAttributes>;
-    getStreamParameter(streamId: string, paramName: string, options?: THttpRequestOptions): Promise<string>;
-    setStream(streamId: string, params: Partial<TStreamAttributes>, options?: THttpRequestOptions): Promise<void>;
-    setStreamParameter(streamId: string, paramName: string, value: string, options?: THttpRequestOptions): Promise<void>;
-    isStreaming(streamId: string, options?: THttpRequestOptions): Promise<boolean>;
-    deleteStream(streamId: string, options?: THttpRequestOptions): Promise<void>;
-    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
-    getUtcTime(options?: THttpRequestOptions): Promise<number>;
-    private get;
-}

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/CreatePackage.d.ts

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

package/esm/PlaneTrackerAPI.d.ts

@@ -1,43 +0,0 @@
-import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
-import { ICAO, TApiUser, TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
-import { THttpRequestOptions, TProxyParams } from './types/common';
-import { ProxyClient } from './internal/ProxyClient';
-export declare class PlaneTrackerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
-    private client;
-    private apiUser;
-    constructor(client: Client, apiUser: TApiUser);
-    static getProxyUrlPath: () => string;
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
-    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
-    resetPtzCalibration: (options?: THttpRequestOptions) => Promise<TResponse>;
-    resetFocusCalibration: (options?: THttpRequestOptions) => Promise<TResponse>;
-    serverRunCheck: (options?: THttpRequestOptions) => Promise<TResponse>;
-    getLiveViewAlias: (rtspUrl: string, options?: THttpRequestOptions) => Promise<TResponse>;
-    fetchCameraSettings: (options?: THttpRequestOptions) => Promise<any>;
-    setCameraSettings: (settingsJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
-    fetchServerSettings: (options?: THttpRequestOptions) => Promise<any>;
-    exportAppSettings: (dataType: TExportDataType, options?: THttpRequestOptions) => Promise<TBlobResponse<Client>>;
-    importAppSettings: (dataType: TImportDataType, formData: FormData, options?: THttpRequestOptions) => Promise<TResponse>;
-    fetchFlightInfo: (icao: ICAO, options?: THttpRequestOptions) => Promise<any>;
-    getTrackingMode: (options?: THttpRequestOptions) => Promise<any>;
-    setTrackingMode: (modeJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
-    startTrackingPlane: (icao: ICAO, options?: THttpRequestOptions) => Promise<TResponse>;
-    stopTrackingPlane: (options?: THttpRequestOptions) => Promise<TResponse>;
-    getPriorityList: (options?: THttpRequestOptions) => Promise<any>;
-    setPriorityList: (priorityListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
-    getWhiteList: (options?: THttpRequestOptions) => Promise<any>;
-    setWhiteList: (whiteListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
-    getBlackList: (options?: THttpRequestOptions) => Promise<any>;
-    setBlackList: (blackListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
-    fetchMapInfo: (options?: THttpRequestOptions) => Promise<any>;
-    getZones: (options?: THttpRequestOptions) => Promise<any>;
-    setZones: (zonesJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
-    goToCoordinates: (lat: number, lon: number, alt?: number, options?: THttpRequestOptions) => Promise<TResponse>;
-    checkGenetecConnection: (params: TParameters, options?: THttpRequestOptions) => Promise<TResponse>;
-    getGenetecCameraList: (params: TParameters, options?: THttpRequestOptions) => Promise<any>;
-    private _getJson;
-    private _getBlob;
-    private parseBlobResponse;
-    private _postJsonEncoded;
-    private _postUrlEncoded;
-}

package/esm/VapixAPI.d.ts

@@ -1,80 +0,0 @@
-import { IClient, TParameters, TResponse } from './internal/types';
-import { TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice, TPortSetSchema, TPortSequenceStateSchema } from './types/VapixAPI';
-import { ProxyClient } from './internal/ProxyClient';
-import { TCameraImageConfig, THttpRequestOptions, TProxyParams } from './types/common';
-export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
-    private client;
-    constructor(client: Client);
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
-    postUrlEncoded(path: string, parameters?: TParameters, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
-    postJson(path: string, jsonData: Record<string, any>, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
-    getCameraImage(parameters: TCameraImageConfig, options?: THttpRequestOptions): Promise<TResponse>;
-    getEventDeclarations(options?: THttpRequestOptions): Promise<string>;
-    getSupportedAudioSampleRate(options?: THttpRequestOptions): Promise<TAudioSampleRates[]>;
-    performAutofocus(options?: THttpRequestOptions): Promise<void>;
-    checkSDCard(options?: THttpRequestOptions): Promise<TSDCardInfo>;
-    mountSDCard(options?: THttpRequestOptions): Promise<number>;
-    unmountSDCard(options?: THttpRequestOptions): Promise<number>;
-    private _doSDCardMountAction;
-    fetchSDCardJobProgress(jobId: number, options?: THttpRequestOptions): Promise<number>;
-    downloadCameraReport(options?: THttpRequestOptions): Promise<TResponse>;
-    getSystemLog(options?: THttpRequestOptions): Promise<TResponse>;
-    getMaxFps(channel: number, options?: THttpRequestOptions): Promise<number>;
-    getTimezone(options?: THttpRequestOptions): Promise<string>;
-    getDateTimeInfo(options?: THttpRequestOptions): Promise<{
-        data: {
-            dateTime: string;
-            dstEnabled: boolean;
-            localDateTime: string;
-            posixTimeZone: string;
-            timeZone?: string | undefined;
-        };
-    }>;
-    getDevicesSettings(options?: THttpRequestOptions): Promise<TAudioDevice[]>;
-    fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, options?: THttpRequestOptions): Promise<any>;
-    getHeaders(options?: THttpRequestOptions): Promise<Record<string, string>>;
-    setHeaders(headers: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
-    getParameter(paramNames: string | string[], options?: THttpRequestOptions): Promise<Record<string, string>>;
-    setParameter(params: Record<string, string | number | boolean>, options?: THttpRequestOptions): Promise<boolean>;
-    getGuardTourList(options?: THttpRequestOptions): 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, options?: THttpRequestOptions): Promise<boolean>;
-    getPTZPresetList(channel: number, options?: THttpRequestOptions): Promise<string[]>;
-    listPTZ(camera: number, options?: THttpRequestOptions): Promise<TCameraPTZItem[]>;
-    listPtzVideoSourceOverview(options?: THttpRequestOptions): Promise<TPtzOverview>;
-    goToPreset(channel: number, presetName: string, options?: THttpRequestOptions): Promise<TResponse>;
-    getPtzPosition(camera: number, options?: THttpRequestOptions): Promise<TCameraPTZItemData>;
-    getPorts(options?: THttpRequestOptions): Promise<{
-        name: string;
-        port: string;
-        state: "open" | "closed";
-        configurable: boolean;
-        usage: string;
-        direction: "input" | "output";
-        normalState: "open" | "closed";
-        readonly?: boolean | undefined;
-    }[]>;
-    setPorts(ports: TPortSetSchema[], options?: THttpRequestOptions): Promise<void>;
-    setPortStateSequence(port: number, sequence: TPortSequenceStateSchema[], options?: THttpRequestOptions): Promise<void>;
-    getApplicationList(options?: THttpRequestOptions): Promise<any>;
-    startApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
-    restartApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
-    stopApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
-    installApplication(data: Blob, fileName: string, options?: THttpRequestOptions): Promise<void>;
-    private static parseParameters;
-    private static parseCameraPtzResponse;
-    private static parsePtz;
-}

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/index.d.ts

@@ -1,23 +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 { PlaneTrackerAPI } from './PlaneTrackerAPI';
-export * from './types/CamSwitcherEvents';
-export * from './types/CamSwitcherAPI';
-export * from './types/VapixAPI';
-export * from './types/CamOverlayAPI';
-export * from './types/PlaneTrackerAPI';
-export { Frame } from './CamOverlayPainter/Frame';
-export { Painter } from './CamOverlayPainter/Painter';
-export { ResourceManager } from './CamOverlayPainter/ResourceManager';
-export * from './types/CamOverlayPainter';
-export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
-export * from './types/CamOverlayDrawingAPI';

package/esm/internal/Digest.d.ts

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

package/esm/internal/constants.d.ts

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

package/esm/internal/transformers.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,14 +0,0 @@
-import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
-import { TParameters, TResponse } from './types';
-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;
-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;

package/esm/internal/versionCompare.d.ts

@@ -1,6 +0,0 @@
-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) => 0 | 1 | -1;
-export declare const versionCompare: (a: string, b: string) => 0 | 1 | -1;
-export declare const fixVersionToDots: (version: string) => string;

package/esm/node/DefaultClient.d.ts

@@ -1,14 +0,0 @@
-import { IClient, HttpOptions, TGetParams, TPostParams } 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: (params: TGetParams) => Promise<UndiciResponse>;
-    post: (params: TPostParams) => Promise<UndiciResponse>;
-    private getBaseConnectionParams;
-}

package/esm/node/HttpRequestSender.d.ts

@@ -1,29 +0,0 @@
-/// <reference types="node" />
-/// <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;
-}