camstreamerlib 4.0.7 → 4.0.9

package/cjs/types/ws/PlaneTrackerEvents.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ptrEventsSchema = exports.wsUserActionData = exports.EUserActions = void 0;
+exports.ptrEventsSchema = exports.EUserActions = void 0;
 const zod_1 = require("zod");
 const PlaneTrackerAPI_1 = require("../PlaneTrackerAPI");
 const wsApiFlightDataSchema = zod_1.z.object({
@@ -33,17 +33,15 @@ const wsCameraPositionDataSchema = zod_1.z.object({
     elevation: zod_1.z.number().min(-90).max(90),
     fov: zod_1.z.number(),
 });
-const apiUserSchema = zod_1.z.object({
-    userId: zod_1.z.string(),
-    userName: zod_1.z.string(),
-    userPriority: zod_1.z.number(),
-    ip: zod_1.z.string(),
-});
-const apiStringUserSchema = zod_1.z.object({
+const userSchema = zod_1.z.object({
     userId: zod_1.z.string(),
     userName: zod_1.z.string(),
     userPriority: zod_1.z.string(),
 });
+const apiUserSchema = userSchema.extend({
+    ip: zod_1.z.string(),
+    userPriority: zod_1.z.number(),
+});
 var EUserActions;
 (function (EUserActions) {
     EUserActions["TRACK_ICAO"] = "trackIcao.cgi";
@@ -58,131 +56,104 @@ var EUserActions;
     EUserActions["LOCK_API"] = "lockApi.cgi";
     EUserActions["UNLOCK_API"] = "unlockApi.cgi";
 })(EUserActions || (exports.EUserActions = EUserActions = {}));
-exports.wsUserActionData = zod_1.z.discriminatedUnion('cgi', [
+const eventsDataSchema = zod_1.z.union([
+    zod_1.z.object({ type: zod_1.z.literal('CAMERA_POSITION') }).merge(wsCameraPositionDataSchema),
+    zod_1.z.object({
+        type: zod_1.z.literal('TRACKING_START'),
+        icao: zod_1.z.string(),
+        targetId: zod_1.z.string(),
+        domain: PlaneTrackerAPI_1.domainIdSchema,
+        categoryId: zod_1.z.string(),
+    }),
+    zod_1.z.object({ type: zod_1.z.literal('TRACKING_STOP') }),
+    zod_1.z.object({ type: zod_1.z.literal('FLIGHT_LIST'), list: zod_1.z.array(wsApiFlightDataSchema) }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.TRACK_ICAO),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema.extend({
-            icao: zod_1.z.string(),
-        }),
+        params: userSchema.extend({ icao: zod_1.z.string() }),
+        postJsonBody: zod_1.z.any(),
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.RESET_ICAO),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
+        postJsonBody: zod_1.z.any(),
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.SET_PRIORITY_LIST),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: PlaneTrackerAPI_1.priorityListSchema,
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.SET_BLACK_LIST),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: PlaneTrackerAPI_1.blackListSchema,
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.SET_WHITE_LIST),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: PlaneTrackerAPI_1.whiteListSchema,
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.GO_TO_COORDINATES),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema.extend({
-            lat: zod_1.z.string(),
-            lon: zod_1.z.string(),
-        }),
+        params: userSchema.extend({ lat: zod_1.z.string(), lon: zod_1.z.string() }),
+        postJsonBody: zod_1.z.any(),
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.SET_TRACKING_MODE),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: PlaneTrackerAPI_1.trackingModeSchema,
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.SET_ZONES),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: PlaneTrackerAPI_1.zonesSchema,
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.RESET_PTZ_CALIBRATION),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
+        postJsonBody: zod_1.z.any(),
     }),
     zod_1.z.object({
+        type: zod_1.z.literal('USER_ACTION'),
         cgi: zod_1.z.literal(EUserActions.LOCK_API),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema.extend({
-            timeout: zod_1.z.string(),
-        }),
-    }),
-    zod_1.z.object({
-        cgi: zod_1.z.literal(EUserActions.UNLOCK_API),
-        ip: zod_1.z.string(),
-        params: apiStringUserSchema,
-    }),
-]);
-const eventsDataSchema = zod_1.z.discriminatedUnion('type', [
-    zod_1.z
-        .object({
-        type: zod_1.z.literal('CAMERA_POSITION'),
-    })
-        .merge(wsCameraPositionDataSchema),
-    zod_1.z.object({
-        type: zod_1.z.literal('TRACKING_START'),
-        icao: zod_1.z.string(),
-    }),
-    zod_1.z.object({
-        type: zod_1.z.literal('TRACKING_STOP'),
-    }),
-    zod_1.z.object({
-        type: zod_1.z.literal('FLIGHT_LIST'),
-        list: zod_1.z.array(wsApiFlightDataSchema),
+        params: userSchema.extend({ timeout: zod_1.z.string() }),
+        postJsonBody: zod_1.z.any(),
     }),
     zod_1.z.object({
         type: zod_1.z.literal('USER_ACTION'),
+        cgi: zod_1.z.literal(EUserActions.UNLOCK_API),
         ip: zod_1.z.string(),
-        params: apiStringUserSchema.extend({
-            lat: zod_1.z.string().optional(),
-            lon: zod_1.z.string().optional(),
-            timeout: zod_1.z.string().optional(),
-        }),
-        cgi: zod_1.z.enum([
-            EUserActions.TRACK_ICAO,
-            EUserActions.RESET_ICAO,
-            EUserActions.SET_PRIORITY_LIST,
-            EUserActions.SET_BLACK_LIST,
-            EUserActions.SET_WHITE_LIST,
-            EUserActions.GO_TO_COORDINATES,
-            EUserActions.SET_TRACKING_MODE,
-            EUserActions.SET_ZONES,
-            EUserActions.RESET_PTZ_CALIBRATION,
-            EUserActions.LOCK_API,
-            EUserActions.UNLOCK_API,
-        ]),
+        params: userSchema,
         postJsonBody: zod_1.z.any(),
     }),
-    zod_1.z.object({
-        type: zod_1.z.literal('CONNECTED_USERS'),
-        users: zod_1.z.array(apiUserSchema),
-    }),
+    zod_1.z.object({ type: zod_1.z.literal('CONNECTED_USERS'), users: zod_1.z.array(apiUserSchema) }),
     zod_1.z.object({
         type: zod_1.z.literal('FORCE_TRACKING_STATUS'),
         enabled: zod_1.z.boolean(),
         icao: zod_1.z.string().optional(),
+        targetId: zod_1.z.string().optional(),
     }),
-    zod_1.z.object({
-        type: zod_1.z.literal('API_LOCK_STATUS'),
-        isLocked: zod_1.z.boolean(),
-        user: apiUserSchema.optional(),
-    }),
+    zod_1.z.object({ type: zod_1.z.literal('API_LOCK_STATUS'), isLocked: zod_1.z.boolean(), user: apiUserSchema.optional() }),
 ]);
-exports.ptrEventsSchema = zod_1.z.discriminatedUnion('type', [
+exports.ptrEventsSchema = zod_1.z.union([
     zod_1.z.object({ type: zod_1.z.literal('init'), data: eventsDataSchema }),
     ...eventsDataSchema.options,
 ]);

package/cjs/ws/PlaneTrackerEvents.js

@@ -6,15 +6,7 @@ const PlaneTrackerEvents_1 = require("../types/ws/PlaneTrackerEvents");
 class PlaneTrackerEvents extends WsEvents_1.WsEvents {
     _apiUser;
     constructor(ws, _apiUser) {
-        super((data) => {
-            const parsedData = PlaneTrackerEvents_1.ptrEventsSchema.parse(data);
-            if (parsedData.type === 'USER_ACTION') {
-                const { type, ...actionData } = parsedData;
-                const userAction = PlaneTrackerEvents_1.wsUserActionData.parse(actionData);
-                return { ...userAction, type };
-            }
-            return parsedData;
-        }, ws);
+        super((data) => PlaneTrackerEvents_1.ptrEventsSchema.parse(data), ws);
         this._apiUser = _apiUser;
         this.ws.onOpen = this.sendInitMsg;
     }

package/esm/PlaneTrackerAPI.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { blackListSchema, cameraSettingsSchema, flightInfoSchema, getIcaoSchema, mapInfoSchema, priorityListSchema, serverSettingsSchema, trackingModeSchema, whiteListSchema, wsAliasResponseSchema, zonesSchema, } from './types/PlaneTrackerAPI';
+import { blackListSchema, cameraSettingsSchema, domainListSchema, flightInfoSchema, getIcaoSchema, mapInfoSchema, priorityListSchema, serverSettingsSchema, trackingModeSchema, whiteListSchema, wsAliasResponseSchema, zonesSchema, } from './types/PlaneTrackerAPI';
 import { CannotSetCoordsInAutoModeError, ImportSettingsError, InvalidAltitudeError, InvalidLatLngError, ResetCalibrationError, ServerError, BadRequestError, } from './errors/errors';
 import { BasicAPI } from './internal/BasicAPI';
 const BASE_PATH = '/local/planetracker';
@@ -85,8 +85,12 @@ export class PlaneTrackerAPI extends BasicAPI {
             throw new ImportSettingsError(res);
         }
     }
-    async fetchFlightInfo(icao, options) {
-        const res = await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao }, options);
+    async getDomainList(options) {
+        const res = await this._getJson(`${BASE_PATH}/getDomainList.cgi`, { action: 'get' }, options);
+        return domainListSchema.parse(res);
+    }
+    async fetchFlightInfo(targetId, options) {
+        const res = await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { targetId }, options);
         return flightInfoSchema.parse(res);
     }
     async getTrackingMode(options) {
@@ -112,9 +116,25 @@ export class PlaneTrackerAPI extends BasicAPI {
             timeout: options?.timeout,
         });
     }
+    async startTrackingTarget(targetId, options) {
+        const agent = this.getClient(options?.proxyParams);
+        await agent.get({
+            path: `${BASE_PATH}/package/trackTarget.cgi`,
+            parameters: { targetId, ...this.apiUser },
+            timeout: options?.timeout,
+        });
+    }
+    async stopTrackingTarget(options) {
+        const agent = this.getClient(options?.proxyParams);
+        await agent.get({
+            path: `${BASE_PATH}/package/resetTarget.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
+    }
     async getIcao(by, value, options) {
         const res = await this._getJson(`${BASE_PATH}/package/getIcao.cgi`, { [by]: value }, options);
-        return getIcaoSchema.parse(res).icao;
+        return getIcaoSchema.parse(res).targetId;
     }
     async getPriorityList(options) {
         const res = await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);

package/esm/VapixAPI.js

@@ -1,5 +1,5 @@
 import { arrayToUrl, isNullish, paramToUrl } from './internal/utils';
-import { sdCardWatchedStatuses, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, guardTourSchema, ptzOverviewSchema, cameraPTZItemDataSchema, applicationListSchema, sdCardInfoSchema, ALL_APP_IDS, } from './types/VapixAPI';
+import { sdCardWatchedStatuses, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, guardTourSchema, ptzOverviewSchema, cameraPTZItemDataSchema, applicationListSchema, sdCardInfoSchema, ALL_APP_IDS, allDateTimeInfoSchema, } from './types/VapixAPI';
 import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, ErrorWithResponse, SDCardActionError, SDCardJobError, SettingParameterError, TimezoneFetchError, TimezoneNotSetupError, } from './errors/errors';
 import { z } from 'zod';
 import { XMLParser } from 'fast-xml-parser';
@@ -149,12 +149,17 @@ export class VapixAPI extends BasicAPI {
             console.warn('Failed to fetch time zone data from time API v2:', error instanceof Error ? error.message : JSON.stringify(error));
             console.warn('Falling back to deprecated time API v1');
         }
-        const data = await this.getDateTimeInfo(options);
+        const data = await this.getAllDateTimeInfo(options);
         if (data.data.timeZone === undefined) {
             throw new TimezoneNotSetupError();
         }
         return z.string().parse(data.data.timeZone);
     }
+    async getAllDateTimeInfo(options) {
+        const data = { apiVersion: '1.0', method: 'getAll' };
+        const res = await this._postJsonEncoded('/axis-cgi/time.cgi', data, undefined, options);
+        return allDateTimeInfoSchema.parse(await res.json());
+    }
     async getDateTimeInfo(options) {
         const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
         const res = await this._postJsonEncoded('/axis-cgi/time.cgi', data, undefined, options);

package/esm/internal/convertors.js

@@ -72,8 +72,8 @@ export const parseVideoOptionsToVapixParams = (firmWareVersion, video) => {
     const nbrOfChannels = video.nbrOfChannels ? (video.audio === 1 ? `&nbrOfChannels=${video.nbrOfChannels}` : '') : '';
     const audioParams = `audio=${video.audio}${nbrOfChannels}`;
     const videoCodecParams = video.videoCodec === 'h264'
-        ? `videoCodec=${video.videoCodec}&h264Profile=${video.h264Profile}`
-        : `videoCodec=${video.videoCodec}`;
+        ? `videocodec=${video.videoCodec}&h264Profile=${video.h264Profile}`
+        : `videocodec=${video.videoCodec}`;
     const videoParams = `camera=${video.camera}&resolution=${video.resolution}&fps=${video.fps}&compression=${video.compression}&videokeyframeinterval=${video.govLength}&${videoCodecParams}${overlaysParams}`;
     return [videoParams, bitrateParams, audioParams].join('&');
 };
@@ -85,7 +85,7 @@ export const parseVapixParamsToVideoOptions = (internalVapixParams) => {
         params[key] = value;
     });
     let h264Profile = undefined;
-    if (params['videoCodec'] === 'h264') {
+    if (params['videocodec'] === 'h264') {
         h264Profile = (params['h264Profile'] ?? 'high');
     }
     let nbrOfChannels = undefined;
@@ -99,7 +99,7 @@ export const parseVapixParamsToVideoOptions = (internalVapixParams) => {
         fps: parseInt(params['fps'] ?? '0', 10),
         compression: parseInt(params['compression'] ?? '0', 10),
         govLength: parseInt(params['videokeyframeinterval'] ?? '0', 10),
-        videoCodec: (params['videoCodec'] ?? 'h264'),
+        videoCodec: (params['videocodec'] ?? 'h264'),
         h264Profile,
         audio: parseInt(params['audio'] ?? '0'),
         nbrOfChannels,

package/esm/types/PlaneTrackerAPI.js

@@ -248,6 +248,7 @@ export const serverSettingsSchema = z.object({
 });
 export const getIcaoSchema = z.object({
     icao: z.string(),
+    targetId: z.string(),
 });
 export const trackingModeSchema = z.object({
     mode: z.union([z.literal('MANUAL'), z.literal('AUTOMATIC')]).default('AUTOMATIC'),
@@ -324,6 +325,18 @@ export const zonesSchema = z.object({
         .default([]),
 });
 export const domainIdSchema = z.enum(['adsb', 'remoteId']);
+const categoryIconSchema = z.enum(['small', 'large', 'heavy', 'helicopter', 'drone', 'operator', 'unknown']);
+const categoryDescriptorSchema = z.object({
+    categoryId: z.string(),
+    uiName: z.string(),
+    icon: categoryIconSchema,
+});
+const domainDescriptorSchema = z.object({
+    uiName: z.string(),
+    icon: categoryIconSchema,
+    categoryList: z.array(categoryDescriptorSchema),
+});
+export const domainListSchema = z.record(domainIdSchema, domainDescriptorSchema);
 export const ADSB_CATEGORY_IDS = {
     A_LIGHT: 'A_LIGHT',
     A_SMALL: 'A_SMALL',

package/esm/types/VapixAPI.js

@@ -120,13 +120,20 @@ export const maxFpsResponseSchema = z.object({
     }))
         .optional(),
 });
+const timeInfoSchema = z.object({
+    dateTime: z.string(),
+    dstEnabled: z.boolean(),
+    localDateTime: z.string(),
+    posixTimeZone: z.string(),
+    timeZone: z.string().optional(),
+});
 export const dateTimeinfoSchema = z.object({
-    data: z.object({
-        dateTime: z.string(),
-        dstEnabled: z.boolean(),
-        localDateTime: z.string(),
-        posixTimeZone: z.string(),
-        timeZone: z.string().optional(),
+    data: timeInfoSchema,
+});
+export const allDateTimeInfoSchema = z.object({
+    data: timeInfoSchema.extend({
+        maxYearSupported: z.number(),
+        timeZones: z.array(z.string()),
     }),
 });
 export const timeZoneSchema = z.discriminatedUnion('status', [

package/esm/types/ws/PlaneTrackerEvents.js

@@ -30,17 +30,15 @@ const wsCameraPositionDataSchema = z.object({
     elevation: z.number().min(-90).max(90),
     fov: z.number(),
 });
-const apiUserSchema = z.object({
-    userId: z.string(),
-    userName: z.string(),
-    userPriority: z.number(),
-    ip: z.string(),
-});
-const apiStringUserSchema = z.object({
+const userSchema = z.object({
     userId: z.string(),
     userName: z.string(),
     userPriority: z.string(),
 });
+const apiUserSchema = userSchema.extend({
+    ip: z.string(),
+    userPriority: z.number(),
+});
 export var EUserActions;
 (function (EUserActions) {
     EUserActions["TRACK_ICAO"] = "trackIcao.cgi";
@@ -55,131 +53,104 @@ export var EUserActions;
     EUserActions["LOCK_API"] = "lockApi.cgi";
     EUserActions["UNLOCK_API"] = "unlockApi.cgi";
 })(EUserActions || (EUserActions = {}));
-export const wsUserActionData = z.discriminatedUnion('cgi', [
+const eventsDataSchema = z.union([
+    z.object({ type: z.literal('CAMERA_POSITION') }).merge(wsCameraPositionDataSchema),
+    z.object({
+        type: z.literal('TRACKING_START'),
+        icao: z.string(),
+        targetId: z.string(),
+        domain: domainIdSchema,
+        categoryId: z.string(),
+    }),
+    z.object({ type: z.literal('TRACKING_STOP') }),
+    z.object({ type: z.literal('FLIGHT_LIST'), list: z.array(wsApiFlightDataSchema) }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.TRACK_ICAO),
         ip: z.string(),
-        params: apiStringUserSchema.extend({
-            icao: z.string(),
-        }),
+        params: userSchema.extend({ icao: z.string() }),
+        postJsonBody: z.any(),
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.RESET_ICAO),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
+        postJsonBody: z.any(),
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.SET_PRIORITY_LIST),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: priorityListSchema,
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.SET_BLACK_LIST),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: blackListSchema,
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.SET_WHITE_LIST),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: whiteListSchema,
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.GO_TO_COORDINATES),
         ip: z.string(),
-        params: apiStringUserSchema.extend({
-            lat: z.string(),
-            lon: z.string(),
-        }),
+        params: userSchema.extend({ lat: z.string(), lon: z.string() }),
+        postJsonBody: z.any(),
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.SET_TRACKING_MODE),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: trackingModeSchema,
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.SET_ZONES),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: zonesSchema,
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.RESET_PTZ_CALIBRATION),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
+        postJsonBody: z.any(),
     }),
     z.object({
+        type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.LOCK_API),
         ip: z.string(),
-        params: apiStringUserSchema.extend({
-            timeout: z.string(),
-        }),
-    }),
-    z.object({
-        cgi: z.literal(EUserActions.UNLOCK_API),
-        ip: z.string(),
-        params: apiStringUserSchema,
-    }),
-]);
-const eventsDataSchema = z.discriminatedUnion('type', [
-    z
-        .object({
-        type: z.literal('CAMERA_POSITION'),
-    })
-        .merge(wsCameraPositionDataSchema),
-    z.object({
-        type: z.literal('TRACKING_START'),
-        icao: z.string(),
-    }),
-    z.object({
-        type: z.literal('TRACKING_STOP'),
-    }),
-    z.object({
-        type: z.literal('FLIGHT_LIST'),
-        list: z.array(wsApiFlightDataSchema),
+        params: userSchema.extend({ timeout: z.string() }),
+        postJsonBody: z.any(),
     }),
     z.object({
         type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.UNLOCK_API),
         ip: z.string(),
-        params: apiStringUserSchema.extend({
-            lat: z.string().optional(),
-            lon: z.string().optional(),
-            timeout: z.string().optional(),
-        }),
-        cgi: z.enum([
-            EUserActions.TRACK_ICAO,
-            EUserActions.RESET_ICAO,
-            EUserActions.SET_PRIORITY_LIST,
-            EUserActions.SET_BLACK_LIST,
-            EUserActions.SET_WHITE_LIST,
-            EUserActions.GO_TO_COORDINATES,
-            EUserActions.SET_TRACKING_MODE,
-            EUserActions.SET_ZONES,
-            EUserActions.RESET_PTZ_CALIBRATION,
-            EUserActions.LOCK_API,
-            EUserActions.UNLOCK_API,
-        ]),
+        params: userSchema,
         postJsonBody: z.any(),
     }),
-    z.object({
-        type: z.literal('CONNECTED_USERS'),
-        users: z.array(apiUserSchema),
-    }),
+    z.object({ type: z.literal('CONNECTED_USERS'), users: z.array(apiUserSchema) }),
     z.object({
         type: z.literal('FORCE_TRACKING_STATUS'),
         enabled: z.boolean(),
         icao: z.string().optional(),
+        targetId: z.string().optional(),
     }),
-    z.object({
-        type: z.literal('API_LOCK_STATUS'),
-        isLocked: z.boolean(),
-        user: apiUserSchema.optional(),
-    }),
+    z.object({ type: z.literal('API_LOCK_STATUS'), isLocked: z.boolean(), user: apiUserSchema.optional() }),
 ]);
-export const ptrEventsSchema = z.discriminatedUnion('type', [
+export const ptrEventsSchema = z.union([
     z.object({ type: z.literal('init'), data: eventsDataSchema }),
     ...eventsDataSchema.options,
 ]);

package/esm/ws/PlaneTrackerEvents.js

@@ -1,17 +1,9 @@
 import { WsEvents } from '../internal/WsEvents';
-import { wsUserActionData, ptrEventsSchema } from '../types/ws/PlaneTrackerEvents';
+import { ptrEventsSchema } from '../types/ws/PlaneTrackerEvents';
 export class PlaneTrackerEvents extends WsEvents {
     _apiUser;
     constructor(ws, _apiUser) {
-        super((data) => {
-            const parsedData = ptrEventsSchema.parse(data);
-            if (parsedData.type === 'USER_ACTION') {
-                const { type, ...actionData } = parsedData;
-                const userAction = wsUserActionData.parse(actionData);
-                return { ...userAction, type };
-            }
-            return parsedData;
-        }, ws);
+        super((data) => ptrEventsSchema.parse(data), ws);
         this._apiUser = _apiUser;
         this.ws.onOpen = this.sendInitMsg;
     }

package/package.json

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

package/types/PlaneTrackerAPI.d.ts

@@ -158,7 +158,16 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     }>;
     exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<ReturnType<Awaited<ReturnType<Client["get"]>>["blob"]>>;
     importAppSettings(dataType: TImportDataType, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
-    fetchFlightInfo(icao: ICAO, options?: THttpRequestOptions): Promise<{
+    getDomainList(options?: THttpRequestOptions): Promise<Partial<Record<"adsb" | "remoteId", {
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+        categoryList: {
+            categoryId: string;
+            uiName: string;
+            icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+        }[];
+    }>>>;
+    fetchFlightInfo(targetId: string, options?: THttpRequestOptions): Promise<{
         destinationAirport: {
             icao?: string | undefined;
             iata?: string | undefined;
@@ -185,6 +194,8 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     setTrackingMode(mode: TTrackingMode['mode'], options?: THttpRequestOptions): Promise<void>;
     startTrackingPlane(icao: ICAO, options?: THttpRequestOptions): Promise<void>;
     stopTrackingPlane(options?: THttpRequestOptions): Promise<void>;
+    startTrackingTarget(targetId: string, options?: THttpRequestOptions): Promise<void>;
+    stopTrackingTarget(options?: THttpRequestOptions): Promise<void>;
     getIcao(by: TGetIcaoByOption, value: string, options?: THttpRequestOptions): Promise<string>;
     getPriorityList(options?: THttpRequestOptions): Promise<{
         list: {

package/types/VapixAPI.d.ts

@@ -21,6 +21,17 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> extends Ba
     getSystemLog(options?: THttpRequestOptions): Promise<string>;
     getMaxFps(channel: number, options?: THttpRequestOptions): Promise<number>;
     getTimezone(options?: THttpRequestOptions): Promise<string>;
+    getAllDateTimeInfo(options?: THttpRequestOptions): Promise<{
+        data: {
+            dateTime: string;
+            dstEnabled: boolean;
+            localDateTime: string;
+            posixTimeZone: string;
+            maxYearSupported: number;
+            timeZones: string[];
+            timeZone?: string | undefined;
+        };
+    }>;
     getDateTimeInfo(options?: THttpRequestOptions): Promise<{
         data: {
             dateTime: string;