camstreamerlib 4.0.0-beta.39 → 4.0.0-beta.40

package/cjs/types/CamScripterAPI.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cameraTimeResponseSchema = exports.camscripterApiResponseSchema = exports.storageSchema = exports.packageConfigSchema = exports.packageInfoListSchema = exports.nodeStateSchema = void 0;
+exports.cameraTimeResponseSchema = exports.camscripterApiResponseSchema = exports.cameraStorageSchema = exports.packageConfigSchema = exports.packageInfoListSchema = exports.nodeStateSchema = void 0;
 const zod_1 = require("zod");
 exports.nodeStateSchema = zod_1.z.object({
     node_state: zod_1.z.union([zod_1.z.literal('OK'), zod_1.z.literal('NOT_INSTALLED'), zod_1.z.literal('NOT_FOUND')]),
@@ -18,7 +18,7 @@ exports.packageInfoListSchema = zod_1.z.array(zod_1.z.object({
     }),
 }));
 exports.packageConfigSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.object({ enabled: zod_1.z.boolean() }));
-exports.storageSchema = zod_1.z.union([
+exports.cameraStorageSchema = zod_1.z.union([
     zod_1.z.tuple([
         zod_1.z.object({ type: zod_1.z.literal('INTERNAL'), capacity_mb: zod_1.z.number() }),
         zod_1.z.object({ type: zod_1.z.literal('SD_CARD'), capacity_mb: zod_1.z.number() }),

package/cjs/types/PlaneTrackerAPI.js

@@ -95,8 +95,10 @@ exports.cameraSettingsSchema = zod_1.z.object({
     trackingConfig: zod_1.z
         .object({
         prioritizeEmergency: zod_1.z.boolean(),
+        guardTourEnabled: zod_1.z.boolean().default(false),
+        guardTourId: zod_1.z.number().int().nonnegative().default(0),
     })
-        .default({ prioritizeEmergency: true }),
+        .default({ prioritizeEmergency: true, guardTourEnabled: false, guardTourId: 0 }),
     overlayText: zod_1.z
         .object({
         displayIcao: zod_1.z.boolean().optional(),

package/esm/CamOverlayAPI.js

@@ -1,5 +1,5 @@
 import { paramToUrl, responseStringify } from './internal/utils';
-import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
+import { ParsingBlobError, ServiceNotFoundError, StorageDataFetchError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
 import { z } from 'zod';
 import { ProxyClient } from './internal/ProxyClient';
@@ -50,7 +50,7 @@ export class CamOverlayAPI {
     async getFileStorage(fileType, options) {
         const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'get_storage' }, options);
         if (res.code !== 200) {
-            throw new Error('Error occured while fetching file storage data');
+            throw new StorageDataFetchError(res);
         }
         return storageDataListSchema.parse(res.list);
     }
@@ -65,7 +65,11 @@ export class CamOverlayAPI {
     }
     async isEnabled(serviceId, options) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ path: `${BASE_PATH}/services.cgi?action=get`, timeout: options?.timeout });
+        const res = await agent.get({
+            path: `${BASE_PATH}/services.cgi`,
+            parameters: { action: 'get' },
+            timeout: options?.timeout,
+        });
         if (res.ok) {
             const data = JSON.parse(await res.text());
             for (const service of data.services) {
@@ -142,7 +146,7 @@ export class CamOverlayAPI {
     async promiseCGUpdate(serviceId, action, params = {}, contentType, data, options) {
         const path = `${BASE_PATH}/customGraphics.cgi`;
         let headers = {};
-        if (contentType !== undefined && data) {
+        if (contentType !== undefined && data !== undefined) {
             headers = { 'Content-Type': contentType };
         }
         const agent = this.getClient(options?.proxyParams);

package/esm/CamScripterAPI.js

@@ -1,6 +1,6 @@
 import { ProxyClient } from './internal/ProxyClient';
 import { responseStringify } from './internal/utils';
-import { cameraTimeResponseSchema, camscripterApiResponseSchema, nodeStateSchema, packageInfoListSchema, storageSchema, } from './types/CamScripterAPI';
+import { cameraTimeResponseSchema, nodeStateSchema, packageInfoListSchema, cameraStorageSchema, } from './types/CamScripterAPI';
 import { networkCameraListSchema } from './types/common';
 const BASE_PATH = '/local/camscripter';
 export class CamScripterAPI {
@@ -22,41 +22,36 @@ export class CamScripterAPI {
     }
     async getStorageInfo(options) {
         const res = await this._getJson(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
-        return storageSchema.parse(res);
+        return cameraStorageSchema.parse(res);
     }
     async getPackageList(options) {
         const res = await this._getJson(`${BASE_PATH}/package/list.cgi`, undefined, options);
         return packageInfoListSchema.parse(res);
     }
     async installPackages(formData, storage, options) {
-        const res = await this._post(`${BASE_PATH}/package/install.cgi`, formData, { storage: storage }, options);
-        return camscripterApiResponseSchema.parse(res);
+        await this._post(`${BASE_PATH}/package/install.cgi`, formData, { storage: storage }, options);
     }
     async uninstallPackage(packageId, options) {
-        const res = await this._getJson(`${BASE_PATH}/package/remove.cgi`, { package_name: packageId }, options);
-        return camscripterApiResponseSchema.parse(res);
+        await this._getJson(`${BASE_PATH}/package/remove.cgi`, { package_name: packageId }, options);
     }
     async importSettings(packageId, formData, options) {
-        const res = await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+        await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
             action: 'IMPORT',
             package_name: packageId,
         }, options);
-        return camscripterApiResponseSchema.parse(res);
     }
     async exportSettings(packageId, formData, options) {
-        const res = await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+        await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
             action: 'EXPORT',
             package_name: packageId,
         }, options);
-        return camscripterApiResponseSchema.parse(res);
     }
     async getNodejsStatus(options) {
         const res = await this._getJson(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
         return nodeStateSchema.parse(res);
     }
     async installNodejs(storage, options) {
-        const res = await this._getJson(`${BASE_PATH}/node_update.cgi`, { storage: storage }, options);
-        return camscripterApiResponseSchema.parse(res);
+        await this._getJson(`${BASE_PATH}/node_update.cgi`, { storage: storage }, options);
     }
     async _getJson(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);

package/esm/CamStreamerAPI.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { ProxyClient } from './internal/ProxyClient';
 import { responseStringify } from './internal/utils';
 import { cameraStreamSchema } from './types/CamStreamerAPI';
+import { UtcTimeFetchError, WsAuthorizationError } from './errors/errors';
 const BASE_PATH = '/local/camstreamer';
 export class CamStreamerAPI {
     client;
@@ -14,14 +15,14 @@ export class CamStreamerAPI {
     async wsAuthorization(options) {
         const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
         if (res.status !== 200) {
-            throw new Error(`Server error on ws authorization: ${res.message}`);
+            throw new WsAuthorizationError(res.message);
         }
         return z.string().parse(res.data);
     }
     async getUtcTime(options) {
         const res = await this._getJson(`${BASE_PATH}/get_utc_time.cgi`, undefined, options);
         if (res.status !== 200) {
-            throw new Error(`Server error on get UTC time: ${res.message}`);
+            throw new UtcTimeFetchError(res.message);
         }
         return z.number().parse(res.data);
     }
@@ -46,7 +47,7 @@ export class CamStreamerAPI {
     }
     async setStream(streamId, params, options) {
         const { streamDelay, startTime, stopTime, ...rest } = params;
-        return await this._getJson(`${BASE_PATH}/stream/set.cgi`, {
+        await this._getJson(`${BASE_PATH}/stream/set.cgi`, {
             stream_id: streamId,
             streamDelay: streamDelay ?? '',
             startTime: startTime ?? null,
@@ -55,7 +56,7 @@ export class CamStreamerAPI {
         }, options);
     }
     async setStreamParameter(streamId, paramName, value, options) {
-        return await this._getJson(`${BASE_PATH}/stream/set.cgi`, { stream_id: streamId, [paramName]: value }, options);
+        await this._getJson(`${BASE_PATH}/stream/set.cgi`, { stream_id: streamId, [paramName]: value }, options);
     }
     async isStreaming(streamId, options) {
         const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);

package/esm/CamSwitcherAPI.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { AddNewClipError } from './errors/errors';
+import { AddNewClipError, JsonParseError, ParameterNotFoundError } from './errors/errors';
 import { isClip, isNullish, responseStringify } from './internal/utils';
 import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, secondaryAudioSettingsSchema, globalAudioSettingsSchema, } from './types/CamSwitcherAPI';
 import { networkCameraListSchema, } from './types/common';
@@ -23,6 +23,14 @@ export class CamSwitcherAPI {
     getClient(proxyParams) {
         return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
     }
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return z.boolean().parse(res.data);
+    }
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return networkCameraListSchema.parse(res.data);
+    }
     async generateSilence(sampleRate, channels, options) {
         const agent = this.getClient(options?.proxyParams);
         await agent.get({
@@ -34,14 +42,6 @@ export class CamSwitcherAPI {
             timeout: options?.timeout,
         });
     }
-    async checkCameraTime(options) {
-        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
-        return z.boolean().parse(res.data);
-    }
-    async getNetworkCameraList(options) {
-        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
-        return networkCameraListSchema.parse(res.data);
-    }
     async getMaxFps(source, options) {
         const res = await this._getJson(`${BASE_PATH}/get_max_framerate.cgi`, {
             video_source: source,
@@ -81,16 +81,16 @@ export class CamSwitcherAPI {
         return trackerSaveLoadSchema.parse(res.data);
     }
     async setStreamSaveList(data, options) {
-        return await this._post(`${BASE_PATH}/streams.cgi`, data, { action: 'set' }, options);
+        await this._post(`${BASE_PATH}/streams.cgi`, data, { action: 'set' }, options);
     }
     async setClipSaveList(data, options) {
-        return await this._post(`${BASE_PATH}/clips.cgi`, data, { action: 'set' }, options);
+        await this._post(`${BASE_PATH}/clips.cgi`, data, { action: 'set' }, options);
     }
     async setPlaylistSaveList(data, options) {
-        return await this._post(`${BASE_PATH}/playlists.cgi`, data, { action: 'set' }, options);
+        await this._post(`${BASE_PATH}/playlists.cgi`, data, { action: 'set' }, options);
     }
     async setTrackerSaveList(data, options) {
-        return await this._post(`${BASE_PATH}/trackers.cgi`, data, { action: 'set' }, options);
+        await this._post(`${BASE_PATH}/trackers.cgi`, data, { action: 'set' }, options);
     }
     async playlistSwitch(playlistName, options) {
         await this._getJson(`${BASE_PATH}/playlist_switch.cgi`, { playlist_name: playlistName }, options);
@@ -128,8 +128,8 @@ export class CamSwitcherAPI {
             throw new AddNewClipError(output.message);
         }
     }
-    removeClip(clipId, storage, options) {
-        return this._getJson(`${BASE_PATH}/clip_remove.cgi`, { clip_name: clipId, storage }, options);
+    async removeClip(clipId, storage, options) {
+        await this._getJson(`${BASE_PATH}/clip_remove.cgi`, { clip_name: clipId, storage }, options);
     }
     async getClipList(options) {
         const res = await this._getJson(`${BASE_PATH}/clip_list.cgi`, undefined, options);
@@ -290,10 +290,10 @@ export class CamSwitcherAPI {
                 }
             }
             catch {
-                throw new Error('Error: in JSON parsing of ' + paramName + '. Cannot parse: ' + data[paramName]);
+                throw new JsonParseError(paramName, data[paramName]);
             }
         }
-        throw new Error("Error: no parametr '" + paramName + "' was found");
+        throw new ParameterNotFoundError(paramName);
     }
 }
 const CSW_PARAM_NAMES = {

package/esm/PlaneTrackerAPI.js

@@ -22,7 +22,7 @@ export class PlaneTrackerAPI {
     }
     async resetPtzCalibration(options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({
+        await agent.get({
             path: `${BASE_PATH}/package/resetPtzCalibration.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
@@ -30,7 +30,7 @@ export class PlaneTrackerAPI {
     }
     async resetFocusCalibration(options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({
+        await agent.get({
             path: `${BASE_PATH}/package/resetFocusCalibration.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
@@ -38,11 +38,11 @@ export class PlaneTrackerAPI {
     }
     async serverRunCheck(options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({ path: `${BASE_PATH}/package/serverRunCheck.cgi`, timeout: options?.timeout });
+        await agent.get({ path: `${BASE_PATH}/package/serverRunCheck.cgi`, timeout: options?.timeout });
     }
     async getLiveViewAlias(rtspUrl, options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({
+        await agent.get({
             path: `${BASE_PATH}/getLiveViewAlias.cgi`,
             parameters: { rtsp_url: rtspUrl },
             timeout: options?.timeout,
@@ -52,8 +52,8 @@ export class PlaneTrackerAPI {
         const res = await this._getJson(`${BASE_PATH}/package_camera_settings.cgi`, { action: 'get' }, options);
         return cameraSettingsSchema.parse(res);
     }
-    async setCameraSettings(settingsJsonString, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settingsJsonString, {
+    async setCameraSettings(settings, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settings, {
             action: 'set',
         }, options);
     }
@@ -66,7 +66,7 @@ export class PlaneTrackerAPI {
     }
     async importAppSettings(dataType, formData, options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.post({
+        await agent.post({
             path: `${BASE_PATH}/package_data.cgi`,
             data: formData,
             parameters: { action: 'IMPORT', dataType },
@@ -82,11 +82,11 @@ export class PlaneTrackerAPI {
         return trackingModeSchema.parse(res);
     }
     async setTrackingMode(mode, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, { mode }, this.apiUser, options);
+        await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, { mode }, this.apiUser, options);
     }
     async startTrackingPlane(icao, options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({
+        await agent.get({
             path: `${BASE_PATH}/package/trackIcao.cgi`,
             parameters: { icao, ...this.apiUser },
             timeout: options?.timeout,
@@ -94,7 +94,7 @@ export class PlaneTrackerAPI {
     }
     async stopTrackingPlane(options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({
+        await agent.get({
             path: `${BASE_PATH}/package/resetIcao.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
@@ -105,21 +105,21 @@ export class PlaneTrackerAPI {
         return priorityListSchema.parse(res);
     }
     async setPriorityList(priorityList, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, { priorityList }, this.apiUser, options);
+        await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, { priorityList }, this.apiUser, options);
     }
     async getWhiteList(options) {
         const res = await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
         return whiteListSchema.parse(res);
     }
     async setWhiteList(whiteList, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, { whiteList }, this.apiUser, options);
+        await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, { whiteList }, this.apiUser, options);
     }
     async getBlackList(options) {
         const res = await this._getJson(`${BASE_PATH}/package/getBlackList.cgi`, undefined, options);
         return blackListSchema.parse(res);
     }
     async setBlackList(blackList, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, { blackList }, this.apiUser, options);
+        await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, { blackList }, this.apiUser, options);
     }
     async fetchMapInfo(options) {
         const res = await this._getJson(`${BASE_PATH}/package/getMapInfo.cgi`, undefined, options);
@@ -130,18 +130,18 @@ export class PlaneTrackerAPI {
         return zonesSchema.parse(res);
     }
     async setZones(zones, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, { zones }, this.apiUser, options);
+        await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, { zones }, this.apiUser, options);
     }
     async goToCoordinates(lat, lon, alt, options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({
+        await agent.get({
             path: `${BASE_PATH}/package/goToCoordinates.cgi`,
             parameters: { lat, lon, alt, ...this.apiUser },
             timeout: options?.timeout,
         });
     }
     async checkGenetecConnection(params, options) {
-        return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, '', params, options);
+        await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, '', params, options);
     }
     async getGenetecCameraList(params, options) {
         const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, '', params, options);

package/esm/VapixAPI.js

@@ -1,6 +1,6 @@
 import { arrayToUrl, isNullish, paramToUrl, responseStringify } from './internal/utils';
 import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, guardTourSchema, ptzOverviewSchema, cameraPTZItemDataSchema, applicationListSchema, sdCardInfoSchema, } from './types/VapixAPI';
-import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, SDCardActionError, SDCardJobError, } from './errors/errors';
+import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, SDCardActionError, SDCardJobError, SettingParameterError, TimezoneFetchError, TimezoneNotSetupError, } from './errors/errors';
 import { ProxyClient } from './internal/ProxyClient';
 import { z } from 'zod';
 import { XMLParser } from 'fast-xml-parser';
@@ -192,7 +192,7 @@ export class VapixAPI {
             const json = await resV2.json();
             const data = timeZoneSchema.parse(json);
             if (data.status === 'error') {
-                throw new Error(data.error.message);
+                throw new TimezoneFetchError(data.error.message);
             }
             return data.data.activeTimeZone;
         }
@@ -202,7 +202,7 @@ export class VapixAPI {
         }
         const data = await this.getDateTimeInfo(options);
         if (data.data.timeZone === undefined) {
-            throw new Error('Time zone not setup on the device');
+            throw new TimezoneNotSetupError();
         }
         return z.string().parse(data.data.timeZone);
     }
@@ -252,7 +252,7 @@ export class VapixAPI {
         }, undefined, options);
         const responseText = await res.text();
         if (responseText.startsWith('# Error')) {
-            throw new Error(responseText);
+            throw new SettingParameterError(responseText);
         }
     }
     async getGuardTourList(options) {
@@ -476,7 +476,7 @@ export class VapixAPI {
         }
         const text = await res.text();
         if (text.length > 5) {
-            throw new Error('installing error: ' + text);
+            throw new ApplicationAPIError('INSTALL', text);
         }
     }
     static parseParameters = (response) => {

package/esm/errors/errors.js

@@ -16,6 +16,24 @@ export class ParsingBlobError extends Error {
         this.name = 'ParsingBlobError';
     }
 }
+export class JsonParseError extends Error {
+    constructor(paramName, data) {
+        super(`Error: in JSON parsing of ${paramName}. Cannot parse: ${data}`);
+        this.name = 'JsonParseError';
+    }
+}
+export class ParameterNotFoundError extends Error {
+    constructor(paramName) {
+        super(`Error: no parameter '${paramName}' was found`);
+        this.name = 'ParameterNotFoundError';
+    }
+}
+export class SettingParameterError extends Error {
+    constructor(message) {
+        super(`Error setting parameter to camera: ${message}`);
+        this.name = 'SettingParameterError';
+    }
+}
 export class ApplicationAPIError extends Error {
     constructor(action, res) {
         super(`[APP ${action}] Error: ` + res);
@@ -70,3 +88,33 @@ export class PtzNotSupportedError extends Error {
         this.name = 'PtzNotSupportedError';
     }
 }
+export class StorageDataFetchError extends Error {
+    constructor(err) {
+        super('Error fetching storage data: ' + err);
+        this.name = 'StorageDataFetchError';
+    }
+}
+export class WsAuthorizationError extends Error {
+    constructor(message) {
+        super('Server error on ws authorization: ' + message);
+        this.name = 'WsAuthorizationError';
+    }
+}
+export class UtcTimeFetchError extends Error {
+    constructor(message) {
+        super('Server error on get UTC time: ' + message);
+        this.name = 'UtcTimeFetchError';
+    }
+}
+export class TimezoneNotSetupError extends Error {
+    constructor() {
+        super('Time zone not setup on the device');
+        this.name = 'TimezoneNotSetupError';
+    }
+}
+export class TimezoneFetchError extends Error {
+    constructor(err) {
+        super('Error fetching time zone information: ' + err);
+        this.name = 'TimezoneFetchError';
+    }
+}

package/esm/index.js

@@ -4,15 +4,17 @@ export * from './internal/utils';
 export * from './internal/versionCompare';
 export * from './internal/ProxyClient';
 export * from './types/common';
-export { CamSwitcherAPI } from './CamSwitcherAPI';
-export { CamSwitcherEvents } from './CamSwitcherEvents';
-export { VapixAPI } from './VapixAPI';
 export { CamOverlayAPI } from './CamOverlayAPI';
+export * from './types/CamOverlayAPI';
 export { CamScripterAPI } from './CamScripterAPI';
+export * from './types/CamScripterAPI';
 export { CamStreamerAPI } from './CamStreamerAPI';
-export { PlaneTrackerAPI } from './PlaneTrackerAPI';
-export * from './types/CamSwitcherEvents';
+export * from './types/CamStreamerAPI';
+export { CamSwitcherAPI } from './CamSwitcherAPI';
 export * from './types/CamSwitcherAPI';
-export * from './types/VapixAPI';
-export * from './types/CamOverlayAPI';
+export { CamSwitcherEvents } from './CamSwitcherEvents';
+export * from './types/CamSwitcherEvents';
+export { PlaneTrackerAPI } from './PlaneTrackerAPI';
 export * from './types/PlaneTrackerAPI';
+export { VapixAPI } from './VapixAPI';
+export * from './types/VapixAPI';

package/esm/node/index.js

@@ -1,8 +1,10 @@
 export * from './DefaultClient';
 export * from './WsClient';
 export * from './HttpServer';
+export * from './HttpRequestSender';
 export * from './events/AxisCameraStationEvents';
 export * from './events/GenetecAgent';
+export * from '../types/GenetecAgent';
 export { ResourceManager } from './CamOverlayPainter/ResourceManager';
 export { Painter } from './CamOverlayPainter/Painter';
 export { Frame } from './CamOverlayPainter/Frame';

package/esm/types/CamOverlayAPI/CamOverlayAPI.js

@@ -49,7 +49,7 @@ export var ImageType;
     ImageType[ImageType["PNG"] = 0] = "PNG";
     ImageType[ImageType["JPEG"] = 1] = "JPEG";
 })(ImageType || (ImageType = {}));
-export const storageSchema = z.union([
+export const fileStorageTypeSchema = z.union([
     z.literal('flash'),
     z.literal('SD0'),
     z.literal('ftp'),
@@ -57,7 +57,7 @@ export const storageSchema = z.union([
     z.literal('url'),
 ]);
 export const storageDataListSchema = z.array(z.object({
-    type: storageSchema,
+    type: fileStorageTypeSchema,
     state: z.string(),
 }));
 export const storageResponseSchema = z.object({
@@ -67,7 +67,7 @@ export const storageResponseSchema = z.object({
 export const fileSchema = z.object({
     name: z.string(),
     path: z.string().url(),
-    storage: storageSchema,
+    storage: fileStorageTypeSchema,
 });
 export const fileListSchema = z.array(fileSchema);
 export const fileDataSchema = z.object({

package/esm/types/CamScripterAPI.js

@@ -15,7 +15,7 @@ export const packageInfoListSchema = z.array(z.object({
     }),
 }));
 export const packageConfigSchema = z.record(z.string(), z.object({ enabled: z.boolean() }));
-export const storageSchema = z.union([
+export const cameraStorageSchema = z.union([
     z.tuple([
         z.object({ type: z.literal('INTERNAL'), capacity_mb: z.number() }),
         z.object({ type: z.literal('SD_CARD'), capacity_mb: z.number() }),

package/esm/types/PlaneTrackerAPI.js

@@ -92,8 +92,10 @@ export const cameraSettingsSchema = z.object({
     trackingConfig: z
         .object({
         prioritizeEmergency: z.boolean(),
+        guardTourEnabled: z.boolean().default(false),
+        guardTourId: z.number().int().nonnegative().default(0),
     })
-        .default({ prioritizeEmergency: true }),
+        .default({ prioritizeEmergency: true, guardTourEnabled: false, guardTourId: 0 }),
     overlayText: z
         .object({
         displayIcao: z.boolean().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.39",
+    "version": "4.0.0-beta.40",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/CamOverlayAPI.d.ts

@@ -1,7 +1,7 @@
 import { IClient, TBlobResponse, TResponse } from './internal/types';
 import { THttpRequestOptions, TProxyParams } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
-import { ImageType, TCoordinates, TField, TFile, TFileType, TStorage, TService } from './types/CamOverlayAPI';
+import { ImageType, TCoordinates, TField, TFile, TFileType, TFileStorageType, TService } from './types/CamOverlayAPI';
 export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
     private client;
     constructor(client: Client);
@@ -21,7 +21,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         name: string;
         storage: "url" | "flash" | "SD0" | "ftp" | "samba";
     }[]>;
-    uploadFile(fileType: TFileType, formData: Parameters<Client['post']>[0]['data'], storage: TStorage, options?: THttpRequestOptions): Promise<void>;
+    uploadFile(fileType: TFileType, formData: Parameters<Client['post']>[0]['data'], storage: TFileStorageType, options?: THttpRequestOptions): Promise<void>;
     removeFile(fileType: TFileType, fileParams: TFile, options?: THttpRequestOptions): Promise<void>;
     getFileStorage(fileType: TFileType, options?: THttpRequestOptions): Promise<{
         type: "url" | "flash" | "SD0" | "ftp" | "samba";

package/types/CamScripterAPI.d.ts

@@ -1,9 +1,9 @@
 import { ProxyClient } from './internal/ProxyClient';
 import { IClient, TResponse } from './internal/types';
-import { TStorageType } from './types/CamScripterAPI';
+import { TCameraStorageType } from './types/CamScripterAPI';
 import { THttpRequestOptions, TProxyParams } from './types/common';
 export declare class CamScripterAPI<Client extends IClient<TResponse, any>> {
-    client: Client;
+    private client;
     constructor(client: Client);
     static getProxyPath: () => string;
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
@@ -34,29 +34,14 @@ export declare class CamScripterAPI<Client extends IClient<TResponse, any>> {
             required_camscripter_rbi_version?: string | undefined;
         };
     }[]>;
-    installPackages(formData: Parameters<Client['post']>[0]['data'], storage: TStorageType, options?: THttpRequestOptions): Promise<{
-        status: number;
-        message: string;
-    }>;
-    uninstallPackage(packageId: string, options?: THttpRequestOptions): Promise<{
-        status: number;
-        message: string;
-    }>;
-    importSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<{
-        status: number;
-        message: string;
-    }>;
-    exportSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<{
-        status: number;
-        message: string;
-    }>;
+    installPackages(formData: Parameters<Client['post']>[0]['data'], storage: TCameraStorageType, options?: THttpRequestOptions): Promise<void>;
+    uninstallPackage(packageId: string, options?: THttpRequestOptions): Promise<void>;
+    importSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
+    exportSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
     getNodejsStatus(options?: THttpRequestOptions): Promise<{
         node_state: "OK" | "NOT_INSTALLED" | "NOT_FOUND";
     }>;
-    installNodejs(storage: TStorageType, options?: THttpRequestOptions): Promise<{
-        status: number;
-        message: string;
-    }>;
+    installNodejs(storage: TCameraStorageType, options?: THttpRequestOptions): Promise<void>;
     private _getJson;
     private _post;
 }