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

package/cjs/types/VapixAPI.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audioSampleRatesResponseSchema = exports.dateTimeinfoSchema = exports.maxFpsResponseSchema = exports.audioDeviceRequestSchema = exports.audioDeviceSchema = exports.audioDeviceInputOutputSchema = exports.audioDeviceConnectionTypeSchema = exports.audioDeviceSignalingTypeSchema = exports.audioDeviceSignalingChannelTypeSchema = exports.cameraPTZItemSchema = exports.cameraPTZItemDataSchema = exports.PtzOverviewSchema = exports.sdCardWatchedStatuses = exports.guardTourSchema = exports.applicationListSchema = exports.APP_IDS = exports.applicationSchema = void 0;
+const zod_1 = require("zod");
+const transformers_1 = require("../internal/transformers");
+exports.applicationSchema = zod_1.z.object({
+    Name: zod_1.z.string(),
+    NiceName: zod_1.z.string(),
+    Vendor: zod_1.z.string(),
+    Version: zod_1.z.string(),
+    ApplicationID: zod_1.z.string().optional(),
+    License: zod_1.z.string(),
+    Status: zod_1.z.string(),
+    ConfigurationPage: zod_1.z.string().optional(),
+    VendorHomePage: zod_1.z.string().optional(),
+    LicenseName: zod_1.z.string().optional(),
+});
+exports.APP_IDS = [
+    'CamStreamer',
+    'CamSwitcher',
+    'CamOverlay',
+    'CamScripter',
+    'PlaneTracker',
+    'Ndihxplugin',
+];
+exports.applicationListSchema = zod_1.z.object({
+    reply: zod_1.z.object({
+        $: zod_1.z.object({ result: zod_1.z.string() }),
+        application: zod_1.z.array(zod_1.z.object({
+            $: exports.applicationSchema,
+        })),
+    }),
+});
+exports.guardTourSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    camNbr: zod_1.z.unknown(),
+    name: zod_1.z.string(),
+    randomEnabled: zod_1.z.unknown(),
+    running: zod_1.z.string(),
+    timeBetweenSequences: zod_1.z.unknown(),
+    tour: zod_1.z.array(zod_1.z.object({
+        moveSpeed: zod_1.z.unknown(),
+        position: zod_1.z.unknown(),
+        presetNbr: zod_1.z.unknown(),
+        waitTime: zod_1.z.unknown(),
+        waitTimeViewType: zod_1.z.unknown(),
+    })),
+});
+const audioSampleRatesSchema = zod_1.z.object({
+    sample_rate: zod_1.z.number(),
+    bit_rates: zod_1.z.array(zod_1.z.number()),
+});
+const audioSampleRatesOutSchema = audioSampleRatesSchema.transform(transformers_1.toCamelCaseDeep);
+exports.sdCardWatchedStatuses = ['OK', 'connected', 'disconnected'];
+exports.PtzOverviewSchema = zod_1.z.record(zod_1.z.number(), zod_1.z.array(zod_1.z.object({ id: zod_1.z.number(), name: zod_1.z.string() })));
+exports.cameraPTZItemDataSchema = zod_1.z.object({
+    pan: zod_1.z.number().optional(),
+    tilt: zod_1.z.number().optional(),
+    zoom: zod_1.z.number().optional(),
+});
+exports.cameraPTZItemSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    id: zod_1.z.number(),
+    data: exports.cameraPTZItemDataSchema,
+});
+exports.audioDeviceSignalingChannelTypeSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    gain: zod_1.z.number(),
+    mute: zod_1.z.boolean(),
+});
+exports.audioDeviceSignalingTypeSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    powerType: zod_1.z.string(),
+    channels: zod_1.z.array(exports.audioDeviceSignalingChannelTypeSchema),
+});
+exports.audioDeviceConnectionTypeSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    signalingTypeSelected: zod_1.z.string(),
+    signalingTypes: zod_1.z.array(exports.audioDeviceSignalingTypeSchema),
+});
+exports.audioDeviceInputOutputSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    enabled: zod_1.z.boolean(),
+    connectionTypes: zod_1.z.array(exports.audioDeviceConnectionTypeSchema),
+    connectionTypeSelected: zod_1.z.string(),
+});
+exports.audioDeviceSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    inputs: zod_1.z.array(exports.audioDeviceInputOutputSchema),
+    outputs: zod_1.z.array(exports.audioDeviceInputOutputSchema),
+});
+const audioDeviceFromRequestSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    inputs: zod_1.z.array(exports.audioDeviceInputOutputSchema).optional(),
+    outputs: zod_1.z.array(exports.audioDeviceInputOutputSchema).optional(),
+});
+exports.audioDeviceRequestSchema = zod_1.z.object({ devices: zod_1.z.array(audioDeviceFromRequestSchema) });
+exports.maxFpsResponseSchema = zod_1.z.object({
+    data: zod_1.z.array(zod_1.z.object({
+        channel: zod_1.z.number(),
+        captureMode: zod_1.z.array(zod_1.z.object({
+            enabled: zod_1.z.boolean(),
+            maxFPS: zod_1.z.number().optional(),
+        })),
+    })),
+});
+exports.dateTimeinfoSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        dateTime: zod_1.z.string(),
+        dstEnabled: zod_1.z.boolean(),
+        localDateTime: zod_1.z.string(),
+        posixTimeZone: zod_1.z.string(),
+        timeZone: zod_1.z.string(),
+    }),
+});
+exports.audioSampleRatesResponseSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        encoders: zod_1.z.union([
+            zod_1.z.object({
+                aac: zod_1.z.array(audioSampleRatesSchema),
+                AAC: zod_1.z.undefined(),
+            }),
+            zod_1.z.object({
+                AAC: zod_1.z.array(audioSampleRatesSchema),
+                aac: zod_1.z.undefined(),
+            }),
+        ]),
+    }),
+});

package/cjs/types/common.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyboardShortcutsSchema = exports.keyboardShortcutSchema = exports.networkCameraListSchema = exports.storageTypeSchema = exports.h264ProfileSchema = exports.audioChannelCountSchema = exports.audioChannelSchema = void 0;
+const zod_1 = require("zod");
+exports.audioChannelSchema = zod_1.z.union([zod_1.z.literal('mono'), zod_1.z.literal('stereo')]);
+exports.audioChannelCountSchema = zod_1.z.union([zod_1.z.literal(1), zod_1.z.literal(2)]);
+exports.h264ProfileSchema = zod_1.z.union([zod_1.z.literal('high'), zod_1.z.literal('main'), zod_1.z.literal('baseline')]);
+exports.storageTypeSchema = zod_1.z.union([zod_1.z.literal('SD_DISK'), zod_1.z.literal('FLASH')]);
+exports.networkCameraListSchema = zod_1.z.array(zod_1.z.object({
+    name: zod_1.z.string(),
+    ip: zod_1.z.string(),
+}));
+exports.keyboardShortcutSchema = zod_1.z.string().nullable();
+exports.keyboardShortcutsSchema = zod_1.z.record(exports.keyboardShortcutSchema);

package/cjs/web/DefaultClient.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultClient = void 0;
+const utils_1 = require("../internal/utils");
+class DefaultClient {
+    get(url, parameters, headers) {
+        return fetch((0, utils_1.addParametersToPath)(url, parameters), {
+            method: 'GET',
+            headers: headers,
+        });
+    }
+    post(url, data, parameters, headers) {
+        return fetch((0, utils_1.addParametersToPath)(url, parameters), {
+            method: 'POST',
+            body: data,
+            headers: headers,
+        });
+    }
+}
+exports.DefaultClient = DefaultClient;

package/cjs/web/WsClient.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = void 0;
+const REFRESH_TIMEOUT = 5_000;
+class WsClient {
+    getUrl;
+    getAuthToken;
+    isDestroyed = false;
+    ws = null;
+    restartTimeout = null;
+    constructor(getUrl, getAuthToken) {
+        this.getUrl = getUrl;
+        this.getAuthToken = getAuthToken;
+    }
+    init() {
+        if (this.isDestroyed) {
+            return;
+        }
+        this.destroyWebsocket();
+        const ws = new WebSocket(this.getUrl(), 'events');
+        ws.onopen = async () => {
+            try {
+                const token = await this.getAuthToken();
+                ws.send(JSON.stringify({ authorization: token }));
+            }
+            catch (error) {
+                console.error('Error sending auth token:', error);
+                ws.close();
+            }
+        };
+        ws.onmessage = (e) => this.onmessage(e);
+        ws.onclose = () => {
+            this.restartTimeout = setTimeout(() => this.init(), REFRESH_TIMEOUT);
+        };
+        this.ws = ws;
+    }
+    send = (msg) => {
+        this.ws?.send(msg);
+    };
+    onmessage = (_) => { };
+    destroy = () => {
+        this.isDestroyed = true;
+        this.destroyWebsocket();
+    };
+    destroyWebsocket() {
+        if (this.restartTimeout) {
+            clearTimeout(this.restartTimeout);
+            this.restartTimeout = null;
+        }
+        if (!this.ws) {
+            return;
+        }
+        this.ws.onmessage = null;
+        this.ws.onopen = null;
+        this.ws.onclose = null;
+        if (this.ws.readyState === this.ws.OPEN) {
+            this.ws.close();
+        }
+        this.ws = null;
+    }
+}
+exports.WsClient = WsClient;

package/cjs/web/index.d.ts

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

package/cjs/web/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = exports.DefaultClient = void 0;
+var DefaultClient_1 = require("./DefaultClient");
+Object.defineProperty(exports, "DefaultClient", { enumerable: true, get: function () { return DefaultClient_1.DefaultClient; } });
+var WsClient_1 = require("./WsClient");
+Object.defineProperty(exports, "WsClient", { enumerable: true, get: function () { return WsClient_1.WsClient; } });

package/esm/CamOverlayAPI.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { IClient } from './internal/common';
+import { CamOverlayOptions, ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TService, TServiceList, TStorage } from './types/CamOverlayAPI';
+import { TNetworkCamera } from './types/common';
+export declare class CamOverlayAPI {
+    private client;
+    constructor(options?: CamOverlayOptions | IClient);
+    checkCameraTime(): Promise<boolean>;
+    getNetworkCameraList(): Promise<TNetworkCamera[]>;
+    wsAutoratization(): Promise<string>;
+    getMjpegStreamImage(mjpegUrl: string): Promise<Blob>;
+    listFiles(fileType: TFileType): Promise<TFileList>;
+    uploadFile(fileType: TFileType, file: Blob, fileName: string): Promise<void>;
+    removeFile(fileType: TFileType, file: TFile): Promise<void>;
+    getFileStorage(fileType: TFileType): Promise<TStorage>;
+    updateInfoticker(serviceID: number, text: string): Promise<void>;
+    setEnabled(serviceID: number, enabled: boolean): Promise<void>;
+    isEnabled(serviceID: number): Promise<boolean>;
+    getSingleService(serviceId: number): Promise<TService>;
+    getServices(): Promise<TService[]>;
+    updateSingleService(serviceId: number, serviceJson: TService): Promise<void>;
+    updateServices(servicesJson: TServiceList): Promise<void>;
+    updateCGText(serviceID: number, fields: TField[]): Promise<void>;
+    updateCGImagePos(serviceID: number, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    updateCGImage(serviceID: number, path: string, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    updateCGImageFromData(serviceID: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    private promiseCGUpdate;
+    private get;
+    private post;
+    private parseBlobResponse;
+}

package/esm/CamOverlayDrawingAPI.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from './internal/common';
+export type CamOverlayDrawingOptions = WsOptions & {
+    camera?: number | number[];
+    zIndex?: number;
+};
+export type TCairoResponse = {
+    message: string;
+    call_id: number;
+};
+export type TCairoCreateResponse = {
+    var: string;
+    call_id: number;
+};
+export type TUploadImageResponse = {
+    var: string;
+    width: number;
+    height: number;
+    call_id: number;
+};
+export type TErrorResponse = {
+    error: string;
+    call_id?: number;
+};
+export type TService = {
+    id: number;
+    enabled: number;
+    schedule: string;
+    name: string;
+    identifier: string;
+    cameraList: number[];
+};
+export type TServiceList = {
+    services: TService[];
+};
+export type TAlign = 'A_RIGHT' | 'A_LEFT' | 'A_CENTER';
+export type TextFit = 'TFM_SCALE' | 'TFM_TRUNCATE' | 'TFM_OVERFLOW';
+export type TWriteTextParams = [string, string, number, number, number, number, TAlign, TextFit?];
+export interface CamOverlayDrawingAPI {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'message', listener: (msg: string) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: 'message', msg: string): boolean;
+}
+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

@@ -0,0 +1,96 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CamOverlayDrawingAPI, TAlign, TCairoCreateResponse, TUploadImageResponse } from '../CamOverlayDrawingAPI';
+import ResourceManager from './ResourceManager';
+export type TRgb = [number, number, number];
+export type TRgba = [number, number, number, number];
+export type TTmf = 'TFM_OVERFLOW' | 'TFM_SCALE' | 'TFM_TRUNCATE';
+export type TObjectFitType = 'fill' | 'fit' | 'none';
+export type TFrameOptions = {
+    enabled?: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text?: string;
+    fontColor?: TRgb;
+    font?: string;
+    bgColor?: TRgba;
+    bgImage?: string;
+    bgType?: TObjectFitType;
+    borderRadius?: number;
+    borderWidth?: number;
+    borderColor?: TRgba;
+    customDraw?: TDrawingCallback;
+    layer?: number;
+};
+export type TFrameInfo = {
+    width: number;
+    height: number;
+};
+export type TDrawingCallback = (cod: CamOverlayDrawingAPI, cairo: string, info: TFrameInfo) => Promise<void>;
+export interface Frame {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'layoutChanged', listener: () => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'layoutChanged'): boolean;
+}
+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;
+    setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
+    setFontColor(fontColor: TRgb): void;
+    setFont(fontName: string): void;
+    setFontData(fontData: TCairoCreateResponse): void;
+    setBgColor(color: TRgba): void;
+    setBgImage(imageName: string, type?: TObjectFitType): void;
+    setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
+    setBgType(type: TObjectFitType): void;
+    setBorderRadius(radius: number): void;
+    setBorderWidth(width: number): void;
+    setBorderColor(color: TRgba): void;
+    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

@@ -0,0 +1,37 @@
+import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
+import ResourceManager from './ResourceManager';
+import { Frame, TFrameOptions } from './Frame';
+export declare const COORD: Record<string, [number, number]>;
+export type TPainterOptions = TFrameOptions & {
+    screenWidth: number;
+    screenHeight: number;
+    coAlignment: string;
+};
+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: string): 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;
+}
+export { Frame, TFrameOptions as FrameOptions, ResourceManager, CamOverlayDrawingOptions };

package/esm/CamOverlayPainter/ResourceManager.d.ts

@@ -0,0 +1,14 @@
+import { CamOverlayDrawingAPI, TUploadImageResponse, TCairoCreateResponse } from '../CamOverlayDrawingAPI';
+export default 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/CamScripterAPI.d.ts

@@ -0,0 +1,19 @@
+import { IClient } from './internal/common';
+import { CamScripterOptions, TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
+import { TNetworkCamera } from './types/common';
+export declare class CamOverlayAPI {
+    private client;
+    constructor(options?: CamScripterOptions | IClient);
+    checkCameraTime(): Promise<boolean>;
+    getStorageInfo(): Promise<TStorage>;
+    getNetworkCameraList(): Promise<TNetworkCamera[]>;
+    getPackageList(): Promise<TPackageInfoList>;
+    installPackages(formData: FormData, storage: TStorageType): Promise<void>;
+    uninstallPackage(packageId: string): Promise<void>;
+    importSettings(packageId: string, formData: FormData): Promise<void>;
+    exportSettings(packageId: string, formData: FormData): Promise<void>;
+    getNodejsStatus(): Promise<TNodeState>;
+    installNodejs(storage: TStorageType): Promise<void>;
+    private get;
+    private post;
+}

package/esm/CamScripterAPICameraEventsGenerator.d.ts

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

@@ -0,0 +1,16 @@
+import { IClient } from './internal/common';
+import { CamStreamerAPIOptions, TStreamAttributes, TStreamList } from './types/CamStreamerAPI';
+export declare class CamStreamerAPI {
+    private client;
+    constructor(options?: CamStreamerAPIOptions | IClient);
+    getStreamList(): Promise<TStreamList>;
+    getStream(streamID: string): Promise<TStreamAttributes>;
+    getStreamParameter(streamID: string, paramName: string): Promise<string>;
+    setStream(streamID: string, params: Partial<TStreamAttributes>): Promise<void>;
+    setStreamParameter(streamID: string, paramName: string, value: string): Promise<void>;
+    isStreaming(streamID: string): Promise<boolean>;
+    deleteStream(streamID: string): Promise<void>;
+    wsAutoratization(): Promise<string>;
+    getUtcTime(): Promise<number>;
+    private get;
+}

package/esm/CamSwitcherAPI.d.ts

@@ -0,0 +1,48 @@
+import { IClient } from './internal/common';
+import { TAudioPushInfo, TOutputInfo, TStorageInfo, TStreamSaveList, TClipList, TStreamSaveLoadList, TClipSaveLoadList, TPlaylistSaveLoadList, TTrackerSaveList, TrackerSaveLoadList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
+import { TAudioChannel, TNetworkCamera, TStorageType } from './types/common';
+export declare class CamSwitcherAPI<Client extends IClient = IClient> {
+    client: Client;
+    private vapixAgent;
+    constructor(client: Client);
+    static getProxyUrlPath: () => string;
+    static getWsEventsUrlPath: () => string;
+    static getClipPreviewUrlPath: (id: string, storage: TStorageType) => string;
+    generateSilence(sampleRate: number, channels: TAudioChannel): Promise<void>;
+    checkCameraTime(): Promise<boolean>;
+    getIpListFromNetworkCheck(): Promise<TNetworkCamera[]>;
+    getMaxFps(source: number): Promise<number>;
+    getStorageInfo(): Promise<TStorageInfo[]>;
+    wsAuthorization(): Promise<string>;
+    getOutputInfo(): Promise<TOutputInfo>;
+    getAudioPushInfo(): Promise<TAudioPushInfo>;
+    getStreamSaveList(): Promise<TStreamSaveLoadList>;
+    getClipSaveList(): Promise<TClipSaveLoadList>;
+    getPlaylistSaveList(): Promise<TPlaylistSaveLoadList>;
+    getTrackerSaveList(): Promise<TrackerSaveLoadList>;
+    setStreamSaveList(data: TStreamSaveList): Promise<boolean>;
+    setClipSaveList(data: TClipSaveList): Promise<boolean>;
+    setPlaylistSaveList(data: TPlaylistSaveList): Promise<boolean>;
+    setTrackerSaveList(data: TTrackerSaveList): Promise<boolean>;
+    playlistSwitch(playlistName: string): Promise<void>;
+    playlistQueuePush(playlistName: string): Promise<void>;
+    playlistQueueClear(): Promise<void>;
+    playlistQueueList(): Promise<string[]>;
+    playlistQueuePlayNext(): Promise<void>;
+    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string): Promise<void>;
+    removeClip(id: string, storage: TStorageType): Promise<any>;
+    getClipList(): Promise<TClipList>;
+    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string): Promise<boolean>;
+    setGlobalAudioSettings(settings: TGlobalAudioSettings): Promise<boolean>;
+    setSecondaryAudioSettings(settings: TSecondaryAudioSettings): Promise<boolean>;
+    setDefaultPlaylist(id: string): Promise<boolean>;
+    setPermanentRtspUrlToken(token: string): Promise<boolean>;
+    getCamSwitchOptions(): Promise<Partial<TCameraOptions>>;
+    getGlobalAudioSettings(): Promise<TGlobalAudioSettings>;
+    getSecondaryAudioSettings(): Promise<TSecondaryAudioSettings>;
+    getPermanentRtspUrlToken(): Promise<string>;
+    private get;
+    private set;
+    private setParamFromCameraJSON;
+    private getParamFromCameraAndJSONParse;
+}