camstreamerlib 3.5.2 → 4.0.0-beta.2

package/CreatePackage.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AdmZip = require("adm-zip");
-const Path = require("path");
-const fs = require("fs");
-const child_process_1 = require("child_process");
+import * as AdmZip from 'adm-zip';
+import * as Path from 'path';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
 const productionModulesFolder = 'production_modules';
 function isDirectory(path) {
     const stat = fs.statSync(path);
@@ -55,7 +53,7 @@ function installDependencies() {
     }
     fs.cpSync('package.json', Path.join(productionModulesFolder, 'package.json'));
     fs.cpSync('package-lock.json', Path.join(productionModulesFolder, 'package-lock.json'));
-    (0, child_process_1.execSync)(`npm ci --omit=dev`, {
+    execSync(`npm ci --omit=dev`, {
         cwd: Path.join(process.cwd(), productionModulesFolder),
     });
 }

package/README.md

@@ -1,4 +1,6 @@
-# CamStreamerLib
+# CamStreamerLib - BETA
+
+**This is beta version of CamStreamerLib v4, dont use it on production. Is going to be changed significantly.**
 
 Node.js helper library for CamStreamer ACAP applications.
 

package/VapixAPI.d.ts

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

package/VapixAPI.js

@@ -0,0 +1,454 @@
+import * as prettifyXml from 'prettify-xml';
+import { parseStringPromise } from 'xml2js';
+import { isNullish, responseStringify } from './internal/common';
+import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, } from './types/VapixAPI';
+import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, SDCardActionError, SDCardJobError, } from './errors/errors';
+import { ProxyClient } from './internal/ProxyClient';
+import { arrayToUrl, paramToUrl } from './internal/utils';
+import { z } from 'zod';
+export class VapixAPI {
+    client;
+    constructor(client, getProxyUrl) {
+        this.client = new ProxyClient(client, getProxyUrl);
+    }
+    async getUrlEncoded(proxy = null, 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);
+        if (!res.ok) {
+            throw new Error(await responseStringify(res));
+        }
+        return res;
+    }
+    async postJson(proxy = null, 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);
+        if (!res.ok) {
+            throw new Error(await responseStringify(res));
+        }
+        return res;
+    }
+    async getCameraImage(params, proxy = null) {
+        return await this.client.get(proxy, '/axis-cgi/jpg/image.cgi', params);
+    }
+    async getEventDeclarations(proxy = null) {
+        const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
+            '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
+            'xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
+            '<GetEventInstances xmlns="http://www.axis.com/vapix/ws/event1"/>' +
+            '</s:Body>' +
+            '</s:Envelope>';
+        const res = await this.client.post(proxy, '/vapix/services', data, { 'Content-Type': 'application/soap+xml' });
+        if (!res.ok) {
+            throw new Error(await responseStringify(res));
+        }
+        const declarations = await res.text();
+        return prettifyXml(declarations);
+    }
+    async getSupportedAudioSampleRate(proxy = null) {
+        const url = '/axis-cgi/audio/streamingcapabilities.cgi';
+        const formData = { apiVersion: '1.0', method: 'list' };
+        const res = await this.postJson(proxy, url, formData);
+        const encoders = audioSampleRatesResponseSchema.parse(await res.json()).data.encoders;
+        const data = encoders.aac ?? encoders.AAC ?? [];
+        return data.map((item) => {
+            return {
+                sampleRate: item.sample_rate,
+                bitRates: item.bit_rates,
+            };
+        });
+    }
+    async performAutofocus(proxy = null) {
+        try {
+            const data = {
+                apiVersion: '1',
+                method: 'performAutofocus',
+                params: {
+                    optics: [
+                        {
+                            opticsId: '0',
+                        },
+                    ],
+                },
+            };
+            await this.postJson(proxy, '/axis-cgi/opticscontrol.cgi', data);
+        }
+        catch (err) {
+            await this.postJson(proxy, '/axis-cgi/opticssetup.cgi', {
+                autofocus: 'perform',
+                source: '1',
+            });
+        }
+    }
+    async checkSDCard(proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/list.cgi', {
+            diskid: 'SD_DISK',
+        });
+        const result = await parseStringPromise(await res.text(), {
+            ignoreAttrs: false,
+            mergeAttrs: true,
+            explicitArray: false,
+        });
+        const data = result.root.disks.disk;
+        return {
+            totalSize: parseInt(data.totalsize),
+            freeSize: parseInt(data.freesize),
+            status: sdCardWatchedStatuses.includes(data.status) ? data.status : 'disconnected',
+        };
+    }
+    mountSDCard(proxy = null) {
+        return this._doSDCardMountAction('MOUNT', proxy);
+    }
+    unmountSDCard(proxy = null) {
+        return this._doSDCardMountAction('UNMOUNT', proxy);
+    }
+    async _doSDCardMountAction(action, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/mount.cgi', {
+            action: action,
+            diskid: 'SD_DISK',
+        });
+        const result = await parseStringPromise(await res.text(), {
+            ignoreAttrs: false,
+            mergeAttrs: true,
+            explicitArray: false,
+        });
+        const job = result.root.job;
+        if (job.result !== 'OK') {
+            throw new SDCardActionError(action, await responseStringify(res));
+        }
+        return Number(job.jobid);
+    }
+    async fetchSDCardJobProgress(jobId, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/disks/job.cgi', {
+            jobid: String(jobId),
+            diskid: 'SD_DISK',
+        });
+        const result = await parseStringPromise(await res.text(), {
+            ignoreAttrs: false,
+            mergeAttrs: true,
+            explicitArray: false,
+        });
+        const job = result.root.job;
+        if (job.result !== 'OK') {
+            throw new SDCardJobError();
+        }
+        return Number(job.progress);
+    }
+    downloadCameraReport(proxy = null) {
+        return this.getUrlEncoded(proxy, '/axis-cgi/serverreport.cgi', { mode: 'text' });
+    }
+    getSystemLog(proxy = null) {
+        return this.getUrlEncoded(proxy, '/axis-cgi/admin/systemlog.cgi');
+    }
+    async getMaxFps(channel, proxy = null) {
+        const data = { apiVersion: '1.0', method: 'getCaptureModes' };
+        const res = await this.postJson(proxy, '/axis-cgi/capturemode.cgi', data);
+        const response = maxFpsResponseSchema.parse(await res.json());
+        const channels = response.data;
+        if (channels === undefined) {
+            throw new MaxFPSError('MALFORMED_REPLY');
+        }
+        const channelData = channels.find((x) => x.channel === channel);
+        if (channelData === undefined) {
+            throw new MaxFPSError('CHANNEL_NOT_FOUND');
+        }
+        const captureModes = channelData.captureMode;
+        const captureMode = captureModes.find((x) => x.enabled === true);
+        if (captureMode === undefined) {
+            throw new MaxFPSError('CAPTURE_MODE_NOT_FOUND');
+        }
+        if (isNullish(captureMode.maxFPS)) {
+            throw new MaxFPSError('FPS_NOT_SPECIFIED');
+        }
+        return captureMode.maxFPS;
+    }
+    async getTimezone(proxy = null) {
+        const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
+        const res = await this.postJson(proxy, '/axis-cgi/time.cgi', data);
+        return (await res.json())?.timeZone ?? 'Europe/Prague';
+    }
+    async getDateTimeInfo(proxy = null) {
+        const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
+        const res = await this.postJson(proxy, '/axis-cgi/time.cgi', data);
+        return dateTimeinfoSchema.parse(await res.json());
+    }
+    async getDevicesSettings(proxy = null) {
+        const data = { apiVersion: '1.0', method: 'getDevicesSettings' };
+        const res = await this.postJson(proxy, '/axis-cgi/audiodevicecontrol.cgi', data);
+        const result = audioDeviceRequestSchema.parse(await res.json());
+        return result.devices.map((device) => ({
+            ...device,
+            inputs: (device.inputs || []).sort((a, b) => a.id.localeCompare(b.id)),
+            outputs: (device.outputs || []).sort((a, b) => a.id.localeCompare(b.id)),
+        }));
+    }
+    async fetchRemoteDeviceInfo(payload, proxy = null) {
+        const res = await this.postJson(proxy, '/axis-cgi/basicdeviceinfo.cgi', payload);
+        const result = await parseStringPromise(await res.text(), {
+            ignoreAttrs: false,
+            mergeAttrs: true,
+            explicitArray: false,
+        });
+        if (isNullish(result.body.data)) {
+            throw new NoDeviceInfoError();
+        }
+        return result.data;
+    }
+    async getHeaders(proxy = null) {
+        const data = { apiVersion: '1.0', method: 'list' };
+        const res = await this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+        return z.object({ data: z.record(z.string()) }).parse(await res.json()).data;
+    }
+    async setHeaders(headers, proxy = null) {
+        const data = { apiVersion: '1.0', method: 'set', params: headers };
+        return this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+    }
+    async getParameter(paramNames, proxy = null) {
+        const response = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+            action: 'list',
+            group: arrayToUrl(paramNames),
+        });
+        return parseParameters(await response.text());
+    }
+    async setParameter(params, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+            ...params,
+            action: 'update',
+        });
+        const responseText = await res.text();
+        if (responseText.startsWith('# Error')) {
+            throw new Error(responseText);
+        }
+        return true;
+    }
+    async getGuardTourList(proxy = null) {
+        const gTourList = new Array();
+        const response = await this.getParameter('GuardTour', proxy);
+        for (let i = 0; i < 20; i++) {
+            const gTourBaseName = 'root.GuardTour.G' + i;
+            if (gTourBaseName + '.CamNbr' in response) {
+                const gTour = {
+                    id: gTourBaseName,
+                    camNbr: response[gTourBaseName + '.CamNbr'],
+                    name: response[gTourBaseName + '.Name'],
+                    randomEnabled: response[gTourBaseName + '.RandomEnabled'],
+                    running: response[gTourBaseName + '.Running'],
+                    timeBetweenSequences: response[gTourBaseName + '.TimeBetweenSequences'],
+                    tour: [],
+                };
+                for (let j = 0; j < 100; j++) {
+                    const tourBaseName = 'root.GuardTour.G' + i + '.Tour.T' + j;
+                    if (tourBaseName + '.MoveSpeed' in response) {
+                        const tour = {
+                            moveSpeed: response[tourBaseName + '.MoveSpeed'],
+                            position: response[tourBaseName + '.Position'],
+                            presetNbr: response[tourBaseName + '.PresetNbr'],
+                            waitTime: response[tourBaseName + '.WaitTime'],
+                            waitTimeViewType: response[tourBaseName + '.WaitTimeViewType'],
+                        };
+                        gTour.tour.push(tour);
+                    }
+                }
+                gTourList.push(gTour);
+            }
+            else {
+                break;
+            }
+        }
+        return gTourList;
+    }
+    setGuardTourEnabled(guardTourID, enable, proxy = null) {
+        const options = {};
+        options[guardTourID + '.Running'] = enable ? 'yes' : 'no';
+        return this.setParameter(options, proxy);
+    }
+    async getPTZPresetList(channel, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            query: 'presetposcam',
+            camera: channel.toString(),
+        });
+        const text = await res.text();
+        const lines = text.split(/[\r\n]/);
+        const positions = [];
+        for (const line of lines) {
+            if (line.indexOf('presetposno') !== -1) {
+                const delimiterPos = line.indexOf('=');
+                if (delimiterPos !== -1) {
+                    const value = line.substring(delimiterPos + 1);
+                    positions.push(value);
+                }
+            }
+        }
+        return positions;
+    }
+    async listPTZ(camera, proxy = null) {
+        const url = `/axis-cgi/com/ptz.cgi`;
+        const response = await this.getUrlEncoded(proxy, url, {
+            camera,
+            query: 'presetposcamdata',
+            format: 'json',
+        });
+        return parseCameraPtzResponse(await response.text())[camera] ?? [];
+    }
+    async listPtzVideoSourceOverview(proxy = null) {
+        const response = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            query: 'presetposall',
+            format: 'json',
+        });
+        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);
+        });
+        return res;
+    }
+    goToPreset(channel, presetName, proxy = null) {
+        return this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            camera: channel.toString(),
+            gotoserverpresetname: presetName,
+        });
+    }
+    async getPtzPosition(camera, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            query: 'position',
+            camera: camera.toString(),
+        });
+        const params = parseParameters(await res.text());
+        return {
+            pan: Number(params.pan),
+            tilt: Number(params.tilt),
+            zoom: Number(params.zoom),
+        };
+    }
+    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;
+    }
+    async setOutputState(port, active, proxy = null) {
+        return this.getUrlEncoded(proxy, '/axis-cgi/io/port.cgi', { action: active ? `${port}:/` : `${port}:\\` });
+    }
+    async getApplicationList(proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/list.cgi');
+        const xml = await res.text();
+        const result = (await parseStringPromise(xml));
+        const apps = [];
+        for (let i = 0; i < result.reply.application.length; i++) {
+            apps.push({
+                ...result.reply.application[i].$,
+                appId: APP_IDS.find((id) => id.toLowerCase() === result.reply.application[i].$.Name.toLowerCase()) ?? null,
+            });
+        }
+        return apps;
+    }
+    async startApplication(applicationID, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+            package: applicationID.toLowerCase(),
+            action: 'start',
+        });
+        const text = (await res.text()).trim().toLowerCase();
+        if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
+            throw new ApplicationAPIError('START', await responseStringify(res));
+        }
+    }
+    async restartApplication(applicationID, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+            package: applicationID.toLowerCase(),
+            action: 'restart',
+        });
+        const text = (await res.text()).trim().toLowerCase();
+        if (text !== 'ok') {
+            throw new ApplicationAPIError('RESTART', await responseStringify(res));
+        }
+    }
+    async stopApplication(applicationID, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+            package: applicationID.toLowerCase(),
+            action: 'stop',
+        });
+        const text = (await res.text()).trim().toLowerCase();
+        if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
+            throw new ApplicationAPIError('STOP', await responseStringify(res));
+        }
+    }
+    async installApplication(data, fileName) {
+        const formData = new FormData();
+        formData.append('packfil', data, fileName);
+        const res = await this.client.post(null, '/axis-cgi/applications/upload.cgi', formData, {}, {
+            contentType: 'application/octet-stream',
+        });
+        if (!res.ok) {
+            throw new Error(await responseStringify(res));
+        }
+        const text = await res.text();
+        if (text.length > 5) {
+            throw new Error('installing error: ' + text);
+        }
+    }
+}
+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') {
+            continue;
+        }
+        const delimiterPos = lines[i].indexOf('=');
+        if (delimiterPos !== -1) {
+            const paramName = lines[i].substring(0, delimiterPos);
+            const paramValue = lines[i].substring(delimiterPos + 1);
+            params[paramName] = paramValue;
+        }
+    }
+    return params;
+};
+const parseCameraPtzResponse = (response) => {
+    const json = JSON.parse(response);
+    const parsed = {};
+    Object.keys(json).forEach((key) => {
+        if (!key.startsWith('Camera ')) {
+            return;
+        }
+        const camera = Number(key.replace('Camera ', ''));
+        if (json[key].presets !== undefined) {
+            parsed[camera] = parsePtz(json[key].presets);
+        }
+    });
+    return parsed;
+};
+const parsePtz = (parsed) => {
+    const res = [];
+    parsed.forEach((value) => {
+        const delimiterPos = value.indexOf('=');
+        if (delimiterPos === -1) {
+            return;
+        }
+        if (!value.startsWith('presetposno')) {
+            return;
+        }
+        const id = Number(value.substring(11, delimiterPos));
+        if (Number.isNaN(id)) {
+            return;
+        }
+        const data = value.substring(delimiterPos + 1).split(':');
+        const getValue = (valueName) => {
+            for (const d of data) {
+                const p = d.split('=');
+                if (p[0] === valueName) {
+                    return Number(p[1]);
+                }
+            }
+            return 0;
+        };
+        res.push({
+            id,
+            name: data[0],
+            data: {
+                pan: getValue('pan'),
+                tilt: getValue('tilt'),
+                zoom: getValue('zoom'),
+            },
+        });
+    });
+    return res;
+};

package/VapixEvents.js

@@ -1,20 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VapixEvents = void 0;
-const eventemitter2_1 = require("eventemitter2");
-const WsClient_1 = require("./internal/WsClient");
-class VapixEvents extends eventemitter2_1.EventEmitter2 {
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { WsClient } from './node/WsClient';
+export class VapixEvents extends EventEmitter {
+    tls;
+    tlsInsecure;
+    ip;
+    port;
+    user;
+    pass;
+    ws;
     constructor(options = {}) {
-        var _a, _b, _c, _d, _e, _f;
         super();
-        this.tls = (_a = options.tls) !== null && _a !== void 0 ? _a : false;
-        this.tlsInsecure = (_b = options.tlsInsecure) !== null && _b !== void 0 ? _b : false;
-        this.ip = (_c = options.ip) !== null && _c !== void 0 ? _c : '127.0.0.1';
-        this.port = (_d = options.port) !== null && _d !== void 0 ? _d : (this.tls ? 443 : 80);
-        this.user = (_e = options.user) !== null && _e !== void 0 ? _e : 'root';
-        this.pass = (_f = options.pass) !== null && _f !== void 0 ? _f : '';
+        this.tls = options.tls ?? false;
+        this.tlsInsecure = options.tlsInsecure ?? false;
+        this.ip = options.ip ?? '127.0.0.1';
+        this.port = options.port ?? (this.tls ? 443 : 80);
+        this.user = options.user ?? 'root';
+        this.pass = options.pass ?? '';
         this.createWsClient();
-        eventemitter2_1.EventEmitter2.call(this);
+        EventEmitter.call(this);
     }
     connect() {
         this.ws.open();
@@ -32,7 +35,7 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
             port: this.port,
             address: '/vapix/ws-data-stream?sources=events',
         };
-        this.ws = new WsClient_1.WsClient(options);
+        this.ws = new WsClient(options);
         this.ws.on('open', () => {
             const topics = [];
             const eventNames = this.eventNames();
@@ -79,4 +82,3 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
         return eventName === 'open' || eventName === 'close' || eventName === 'error';
     }
 }
-exports.VapixEvents = VapixEvents;

package/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 {};