camstreamerlib 4.0.0-beta.7 → 4.0.0-beta.71

package/cjs/{CreatePackage.js → bin/CreatePackage.js}

@@ -1,17 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const AdmZip = require("adm-zip");
-const Path = require("path");
-const fs = require("fs");
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 const child_process_1 = require("child_process");
 const productionModulesFolder = 'production_modules';
-function isDirectory(path) {
-    const stat = fs.statSync(path);
+function isDirectory(filePath) {
+    const stat = fs.statSync(filePath);
     return stat.isDirectory();
 }
 function getPackageInfo(folder) {
     try {
-        const manifest = fs.readFileSync(Path.join(folder, 'manifest.json'));
+        const manifest = fs.readFileSync(path.join(folder, 'manifest.json'));
         const manifestParsed = JSON.parse(manifest.toString());
         return {
             packageName: manifestParsed.package_name,
@@ -23,11 +49,11 @@ function getPackageInfo(folder) {
     }
 }
 function createZipArchive(zip, folder, options) {
-    const zipFileRegex = new RegExp(`${Path.basename(folder)}(_[0-9]){3}\\.zip`);
+    const zipFileRegex = new RegExp(`${path.basename(folder)}(_[0-9]){3}\\.zip`);
     const files = fs.readdirSync(folder);
     for (const file of files) {
-        const path = Path.join(folder, file);
-        const isDir = isDirectory(path);
+        const filePath = path.join(folder, file);
+        const isDir = isDirectory(filePath);
         if (file[0] === '.' ||
             zipFileRegex.test(file) ||
             file === 'node_modules' ||
@@ -36,16 +62,16 @@ function createZipArchive(zip, folder, options) {
             continue;
         }
         else if (file === 'dist' && options.typeScriptPackage) {
-            zip.addLocalFolder(path);
+            zip.addLocalFolder(filePath);
         }
         else if (file === productionModulesFolder && options.includeNodeModules) {
-            zip.addLocalFolder(Path.join(productionModulesFolder, 'node_modules'), 'node_modules');
+            zip.addLocalFolder(path.join(productionModulesFolder, 'node_modules'), 'node_modules');
         }
         else if (isDir) {
-            zip.addLocalFolder(path, file);
+            zip.addLocalFolder(filePath, file);
         }
         else {
-            zip.addLocalFile(path);
+            zip.addLocalFile(filePath);
         }
     }
 }
@@ -53,10 +79,10 @@ function installDependencies() {
     if (!fs.existsSync(productionModulesFolder)) {
         fs.mkdirSync(productionModulesFolder, {});
     }
-    fs.cpSync('package.json', Path.join(productionModulesFolder, 'package.json'));
-    fs.cpSync('package-lock.json', Path.join(productionModulesFolder, 'package-lock.json'));
+    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`, {
-        cwd: Path.join(process.cwd(), productionModulesFolder),
+        cwd: path.join(process.cwd(), productionModulesFolder),
     });
 }
 function main(args) {
@@ -83,7 +109,7 @@ function main(args) {
     if (fs.existsSync('dist')) {
         options.typeScriptPackage = true;
     }
-    const folder = Path.resolve('.');
+    const folder = path.resolve('.');
     const packageInfo = getPackageInfo(folder);
     if (packageInfo === undefined) {
         console.error('Package info not found');
@@ -99,7 +125,7 @@ function main(args) {
             process.exit(1);
         }
     }
-    const zip = new AdmZip();
+    const zip = new adm_zip_1.default();
     createZipArchive(zip, folder, options);
     zip.writeZip(zipFile);
 }

package/cjs/errors/errors.d.ts

@@ -1,3 +1,8 @@
+import { TResponse } from '../internal/types';
+export declare class ErrorWithResponse<T extends TResponse> extends Error {
+    res: T;
+    constructor(res: T);
+}
 export declare class ServiceUnavailableError extends Error {
     constructor();
 }
@@ -7,16 +12,27 @@ export declare class ServiceNotFoundError extends Error {
 export declare class ParsingBlobError extends Error {
     constructor(err: unknown);
 }
-type TApplicationAPIAction = 'START' | 'RESTART' | 'STOP';
+export declare class JsonParseError extends Error {
+    constructor(paramName: string, data: unknown);
+}
+export declare class ParameterNotFoundError extends Error {
+    constructor(paramName: string);
+}
+export declare class SettingParameterError extends Error {
+    constructor(message: string);
+}
+type TApplicationAPIAction = 'START' | 'RESTART' | 'STOP' | 'INSTALL';
 export declare class ApplicationAPIError extends Error {
-    constructor(action: TApplicationAPIAction, res: string);
+    action: TApplicationAPIAction;
+    constructor(action: TApplicationAPIAction, reason: string);
 }
 type TSDCardAction = 'MOUNT' | 'UNMOUNT';
 export declare class SDCardActionError extends Error {
-    constructor(action: TSDCardAction, res: string);
+    action: TSDCardAction;
+    constructor(action: TSDCardAction, reason: string);
 }
 export declare class SDCardJobError extends Error {
-    constructor();
+    constructor(reason: string);
 }
 type TMaxFPSErrorType = 'MALFORMED_REPLY' | 'CHANNEL_NOT_FOUND' | 'CAPTURE_MODE_NOT_FOUND' | 'FPS_NOT_SPECIFIED';
 export declare class MaxFPSError extends Error {
@@ -31,4 +47,45 @@ export declare class FetchDeviceInfoError extends Error {
 export declare class AddNewClipError extends Error {
     constructor(message: string);
 }
+export declare class PtzNotSupportedError extends Error {
+    constructor();
+}
+export declare class StorageDataFetchError extends Error {
+    constructor(err: unknown);
+}
+export declare class WsAuthorizationError extends Error {
+    constructor(message: string);
+}
+export declare class UtcTimeFetchError extends Error {
+    constructor(message: string);
+}
+export declare class TimezoneNotSetupError extends Error {
+    constructor();
+}
+export declare class TimezoneFetchError extends Error {
+    constructor(err: unknown);
+}
+type TCalibrationType = 'PTZ' | 'FOCUS';
+export declare class ResetCalibrationError<T extends TResponse> extends ErrorWithResponse<T> {
+    type: TCalibrationType;
+    constructor(type: TCalibrationType, res: T);
+}
+export declare class ImportSettingsError<T extends TResponse> extends ErrorWithResponse<T> {
+    constructor(res: T);
+}
+export declare class CannotSetCoordsInAutoModeError extends Error {
+    constructor();
+}
+export declare class InvalidLatLngError extends Error {
+    constructor();
+}
+export declare class InvalidAltitudeError extends Error {
+    constructor();
+}
+export declare class ServerError extends Error {
+    constructor();
+}
+export declare class BadRequestError<T extends TResponse> extends ErrorWithResponse<T> {
+    constructor(res: T);
+}
 export {};

package/cjs/errors/errors.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddNewClipError = exports.FetchDeviceInfoError = exports.NoDeviceInfoError = exports.MaxFPSError = exports.SDCardJobError = exports.SDCardActionError = exports.ApplicationAPIError = exports.ParsingBlobError = exports.ServiceNotFoundError = exports.ServiceUnavailableError = void 0;
+exports.BadRequestError = exports.ServerError = exports.InvalidAltitudeError = exports.InvalidLatLngError = exports.CannotSetCoordsInAutoModeError = exports.ImportSettingsError = exports.ResetCalibrationError = exports.TimezoneFetchError = exports.TimezoneNotSetupError = exports.UtcTimeFetchError = exports.WsAuthorizationError = exports.StorageDataFetchError = exports.PtzNotSupportedError = exports.AddNewClipError = exports.FetchDeviceInfoError = exports.NoDeviceInfoError = exports.MaxFPSError = exports.SDCardJobError = exports.SDCardActionError = exports.ApplicationAPIError = exports.SettingParameterError = exports.ParameterNotFoundError = exports.JsonParseError = exports.ParsingBlobError = exports.ServiceNotFoundError = exports.ServiceUnavailableError = exports.ErrorWithResponse = void 0;
+class ErrorWithResponse extends Error {
+    res;
+    constructor(res) {
+        super(res.statusText);
+        this.res = res;
+        this.name = 'ErrorWithResponse';
+    }
+}
+exports.ErrorWithResponse = ErrorWithResponse;
 class ServiceUnavailableError extends Error {
     constructor() {
         super('Service is unavailable.');
@@ -22,23 +31,48 @@ class ParsingBlobError extends Error {
     }
 }
 exports.ParsingBlobError = ParsingBlobError;
+class JsonParseError extends Error {
+    constructor(paramName, data) {
+        super(`Error: in JSON parsing of ${paramName}. Cannot parse: ${data}`);
+        this.name = 'JsonParseError';
+    }
+}
+exports.JsonParseError = JsonParseError;
+class ParameterNotFoundError extends Error {
+    constructor(paramName) {
+        super(`Error: no parameter '${paramName}' was found`);
+        this.name = 'ParameterNotFoundError';
+    }
+}
+exports.ParameterNotFoundError = ParameterNotFoundError;
+class SettingParameterError extends Error {
+    constructor(message) {
+        super(`Error setting parameter to camera: ${message}`);
+        this.name = 'SettingParameterError';
+    }
+}
+exports.SettingParameterError = SettingParameterError;
 class ApplicationAPIError extends Error {
-    constructor(action, res) {
-        super(`[APP ${action}] Error: ` + res);
+    action;
+    constructor(action, reason) {
+        super(`Error performing application action '${action}': ${reason}`);
+        this.action = action;
         this.name = 'ApplicationAPIError';
     }
 }
 exports.ApplicationAPIError = ApplicationAPIError;
 class SDCardActionError extends Error {
-    constructor(action, res) {
-        super(`[SD_CARD ${action}] Error: ` + res);
+    action;
+    constructor(action, reason) {
+        super(`Error performing SD card action '${action}': ${reason}`);
+        this.action = action;
         this.name = 'SDCardActionError';
     }
 }
 exports.SDCardActionError = SDCardActionError;
 class SDCardJobError extends Error {
-    constructor() {
-        super('Error while fetching SD card job progress');
+    constructor(reason) {
+        super(`Error while fetching SD card job progress: ${reason}`);
         this.name = 'SDCardJobError';
     }
 }
@@ -77,3 +111,96 @@ class AddNewClipError extends Error {
     }
 }
 exports.AddNewClipError = AddNewClipError;
+class PtzNotSupportedError extends Error {
+    constructor() {
+        super('Ptz not supported.');
+        this.name = 'PtzNotSupportedError';
+    }
+}
+exports.PtzNotSupportedError = PtzNotSupportedError;
+class StorageDataFetchError extends Error {
+    constructor(err) {
+        super('Error fetching storage data: ' + err);
+        this.name = 'StorageDataFetchError';
+    }
+}
+exports.StorageDataFetchError = StorageDataFetchError;
+class WsAuthorizationError extends Error {
+    constructor(message) {
+        super('Server error on ws authorization: ' + message);
+        this.name = 'WsAuthorizationError';
+    }
+}
+exports.WsAuthorizationError = WsAuthorizationError;
+class UtcTimeFetchError extends Error {
+    constructor(message) {
+        super('Server error on get UTC time: ' + message);
+        this.name = 'UtcTimeFetchError';
+    }
+}
+exports.UtcTimeFetchError = UtcTimeFetchError;
+class TimezoneNotSetupError extends Error {
+    constructor() {
+        super('Time zone not setup on the device');
+        this.name = 'TimezoneNotSetupError';
+    }
+}
+exports.TimezoneNotSetupError = TimezoneNotSetupError;
+class TimezoneFetchError extends Error {
+    constructor(err) {
+        super('Error fetching time zone information: ' + err);
+        this.name = 'TimezoneFetchError';
+    }
+}
+exports.TimezoneFetchError = TimezoneFetchError;
+class ResetCalibrationError extends ErrorWithResponse {
+    type;
+    constructor(type, res) {
+        super(res);
+        this.type = type;
+        this.name = 'ResetCalibrationError';
+    }
+}
+exports.ResetCalibrationError = ResetCalibrationError;
+class ImportSettingsError extends ErrorWithResponse {
+    constructor(res) {
+        super(res);
+        this.name = 'ImportSettingsError';
+    }
+}
+exports.ImportSettingsError = ImportSettingsError;
+class CannotSetCoordsInAutoModeError extends Error {
+    constructor() {
+        super("The automatic mode doesn't allow control of the camera.");
+        this.name = 'CannotSetCoordsInAutoModeError';
+    }
+}
+exports.CannotSetCoordsInAutoModeError = CannotSetCoordsInAutoModeError;
+class InvalidLatLngError extends Error {
+    constructor() {
+        super('The provided latitude or longitude parameters are invalid.');
+        this.name = 'InvalidLatLngError';
+    }
+}
+exports.InvalidLatLngError = InvalidLatLngError;
+class InvalidAltitudeError extends Error {
+    constructor() {
+        super('The provided altitude parameter is invalid.');
+        this.name = 'InvalidAltitudeError';
+    }
+}
+exports.InvalidAltitudeError = InvalidAltitudeError;
+class ServerError extends Error {
+    constructor() {
+        super('An internal server error occurred.');
+        this.name = 'ServerError';
+    }
+}
+exports.ServerError = ServerError;
+class BadRequestError extends ErrorWithResponse {
+    constructor(res) {
+        super(res);
+        this.name = 'BadRequestError';
+    }
+}
+exports.BadRequestError = BadRequestError;

package/cjs/index.d.ts

@@ -1,11 +1,27 @@
-export * from './internal/common';
+export * from './errors/errors';
+export * from './internal/types';
 export * from './internal/constants';
 export * from './internal/utils';
 export * from './internal/versionCompare';
+export * from './internal/ProxyClient';
 export * from './types/common';
+export { CamStreamerAPI } from './CamStreamerAPI';
+export * from './types/CamStreamerAPI';
+export { CamStreamerEvents } from './ws/CamStreamerEvents';
+export * from './types/ws/CamStreamerEvents';
+export { CamOverlayAPI } from './CamOverlayAPI';
+export * from './types/CamOverlayAPI';
+export { CamOverlayEvents } from './ws/CamOverlayEvents';
+export * from './types/ws/CamOverlayEvents';
 export { CamSwitcherAPI } from './CamSwitcherAPI';
-export { CamSwitcherEvents } from './CamSwitcherEvents';
-export { VapixAPI } from './VapixAPI';
-export * from './types/CamSwitcherEvents';
 export * from './types/CamSwitcherAPI';
+export { CamSwitcherEvents } from './ws/CamSwitcherEvents';
+export * from './types/ws/CamSwitcherEvents';
+export { PlaneTrackerAPI } from './PlaneTrackerAPI';
+export * from './types/PlaneTrackerAPI';
+export { PlaneTrackerEvents } from './ws/PlaneTrackerEvents';
+export * from './types/ws/PlaneTrackerEvents';
+export { CamScripterAPI } from './CamScripterAPI';
+export * from './types/CamScripterAPI';
+export { VapixAPI } from './VapixAPI';
 export * from './types/VapixAPI';

package/cjs/index.js

@@ -14,18 +14,41 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VapixAPI = exports.CamSwitcherEvents = exports.CamSwitcherAPI = void 0;
-__exportStar(require("./internal/common"), exports);
+exports.VapixAPI = exports.CamScripterAPI = exports.PlaneTrackerEvents = exports.PlaneTrackerAPI = exports.CamSwitcherEvents = exports.CamSwitcherAPI = exports.CamOverlayEvents = exports.CamOverlayAPI = exports.CamStreamerEvents = exports.CamStreamerAPI = void 0;
+__exportStar(require("./errors/errors"), exports);
+__exportStar(require("./internal/types"), exports);
 __exportStar(require("./internal/constants"), exports);
 __exportStar(require("./internal/utils"), exports);
 __exportStar(require("./internal/versionCompare"), exports);
+__exportStar(require("./internal/ProxyClient"), exports);
 __exportStar(require("./types/common"), exports);
+var CamStreamerAPI_1 = require("./CamStreamerAPI");
+Object.defineProperty(exports, "CamStreamerAPI", { enumerable: true, get: function () { return CamStreamerAPI_1.CamStreamerAPI; } });
+__exportStar(require("./types/CamStreamerAPI"), exports);
+var CamStreamerEvents_1 = require("./ws/CamStreamerEvents");
+Object.defineProperty(exports, "CamStreamerEvents", { enumerable: true, get: function () { return CamStreamerEvents_1.CamStreamerEvents; } });
+__exportStar(require("./types/ws/CamStreamerEvents"), exports);
+var CamOverlayAPI_1 = require("./CamOverlayAPI");
+Object.defineProperty(exports, "CamOverlayAPI", { enumerable: true, get: function () { return CamOverlayAPI_1.CamOverlayAPI; } });
+__exportStar(require("./types/CamOverlayAPI"), exports);
+var CamOverlayEvents_1 = require("./ws/CamOverlayEvents");
+Object.defineProperty(exports, "CamOverlayEvents", { enumerable: true, get: function () { return CamOverlayEvents_1.CamOverlayEvents; } });
+__exportStar(require("./types/ws/CamOverlayEvents"), exports);
 var CamSwitcherAPI_1 = require("./CamSwitcherAPI");
 Object.defineProperty(exports, "CamSwitcherAPI", { enumerable: true, get: function () { return CamSwitcherAPI_1.CamSwitcherAPI; } });
-var CamSwitcherEvents_1 = require("./CamSwitcherEvents");
+__exportStar(require("./types/CamSwitcherAPI"), exports);
+var CamSwitcherEvents_1 = require("./ws/CamSwitcherEvents");
 Object.defineProperty(exports, "CamSwitcherEvents", { enumerable: true, get: function () { return CamSwitcherEvents_1.CamSwitcherEvents; } });
+__exportStar(require("./types/ws/CamSwitcherEvents"), exports);
+var PlaneTrackerAPI_1 = require("./PlaneTrackerAPI");
+Object.defineProperty(exports, "PlaneTrackerAPI", { enumerable: true, get: function () { return PlaneTrackerAPI_1.PlaneTrackerAPI; } });
+__exportStar(require("./types/PlaneTrackerAPI"), exports);
+var PlaneTrackerEvents_1 = require("./ws/PlaneTrackerEvents");
+Object.defineProperty(exports, "PlaneTrackerEvents", { enumerable: true, get: function () { return PlaneTrackerEvents_1.PlaneTrackerEvents; } });
+__exportStar(require("./types/ws/PlaneTrackerEvents"), exports);
+var CamScripterAPI_1 = require("./CamScripterAPI");
+Object.defineProperty(exports, "CamScripterAPI", { enumerable: true, get: function () { return CamScripterAPI_1.CamScripterAPI; } });
+__exportStar(require("./types/CamScripterAPI"), exports);
 var VapixAPI_1 = require("./VapixAPI");
 Object.defineProperty(exports, "VapixAPI", { enumerable: true, get: function () { return VapixAPI_1.VapixAPI; } });
-__exportStar(require("./types/CamSwitcherEvents"), exports);
-__exportStar(require("./types/CamSwitcherAPI"), exports);
 __exportStar(require("./types/VapixAPI"), exports);

package/cjs/internal/ProxyClient.d.ts

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

package/cjs/internal/ProxyClient.js

@@ -4,41 +4,37 @@ exports.ProxyClient = void 0;
 const utils_1 = require("./utils");
 class ProxyClient {
     client;
-    getProxyUrl;
-    constructor(client, getProxyUrl) {
+    proxyParams;
+    constructor(client, proxyParams) {
         this.client = client;
-        this.getProxyUrl = getProxyUrl;
+        this.proxyParams = proxyParams;
     }
-    get = (proxy, path, parameters, headers = {}) => {
-        const url = (0, utils_1.addParametersToPath)(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.get(realUrl, {}, realHeaders);
-    };
-    post = (proxy, path, data, parameters, headers) => {
-        const url = (0, utils_1.addParametersToPath)(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.post(realUrl, data, {}, realHeaders);
-    };
-    getReal = (proxy, url, headers) => {
-        if (proxy !== null) {
-            return {
-                realUrl: this.getProxyUrl(),
-                realHeaders: {
-                    ...(headers ?? {}),
-                    'x-target-camera-protocol': proxy.port === 443 ? 'https' : 'http',
-                    'x-target-camera-path': url,
-                    'x-target-camera-ip': proxy.ip,
-                    'x-target-camera-mdns': proxy.mdnsName,
-                    'x-target-camera-port': String(proxy.port),
-                    'x-target-camera-pass': encodeURIComponent(proxy.pass),
-                    'x-target-camera-user': encodeURIComponent(proxy.user),
-                },
-            };
-        }
+    get(params) {
+        const { path, parameters, headers, timeout } = params;
+        const targetPath = (0, utils_1.addParametersToPath)(path, parameters);
+        const { realPath, realHeaders } = this.getReal(targetPath, headers);
+        return this.client.get({ path: realPath, headers: realHeaders, timeout });
+    }
+    post(params) {
+        const { path, data, parameters, headers, timeout } = params;
+        const targetPath = (0, utils_1.addParametersToPath)(path, parameters);
+        const { realPath, realHeaders } = this.getReal(targetPath, headers);
+        return this.client.post({ path: realPath, data, headers: realHeaders, timeout });
+    }
+    getReal(targetPath, headers) {
         return {
-            realUrl: url,
-            realHeaders: headers,
+            realPath: this.proxyParams.path,
+            realHeaders: {
+                ...(headers ?? {}),
+                'x-target-camera-protocol': this.proxyParams.target.port === 443 ? 'https' : 'http',
+                'x-target-camera-path': targetPath,
+                'x-target-camera-ip': this.proxyParams.target.ip,
+                'x-target-camera-mdns': this.proxyParams.target.mdnsName,
+                'x-target-camera-port': String(this.proxyParams.target.port),
+                'x-target-camera-pass': this.proxyParams.target.pass,
+                'x-target-camera-user': this.proxyParams.target.user,
+            },
         };
-    };
+    }
 }
 exports.ProxyClient = ProxyClient;

package/cjs/internal/WsEvents.d.ts

@@ -0,0 +1,37 @@
+import { IWsClient } from './types';
+type TEventType<T extends {
+    type: string;
+}> = T extends {
+    type: infer Type;
+} ? Type : never;
+type TEvent<T extends {
+    type: string;
+}, Type extends TEventType<T>> = T extends {
+    type: Type;
+} ? T : never;
+type TValidate<T extends {
+    type: string;
+}> = (data: string) => {
+    type: 'init';
+    data: TEvent<T, TEventType<T>>;
+} | TEvent<T, TEventType<T>>;
+type TListenerFunction<T extends {
+    type: string;
+}, Type extends TEventType<T>> = (data: TEvent<T, Type>, isInit: boolean) => void;
+export declare class WsEvents<T extends {
+    type: string;
+}> {
+    private validate;
+    ws: IWsClient;
+    private _isDestroyed;
+    private listeners;
+    constructor(validate: TValidate<T>, ws: IWsClient);
+    get isDestroyed(): boolean;
+    resendInitData(): void;
+    addListener<Type extends TEventType<T>>(type: Type, listener: TListenerFunction<T, Type>, id: string): void;
+    removeListener<Type extends TEventType<T>>(type: Type, id: string): void;
+    private onMessage;
+    private processMessage;
+    destroy(): void;
+}
+export {};