camstreamerlib 4.0.0-beta.37 → 4.0.0-beta.39

package/esm/PlaneTrackerAPI.js

@@ -1,7 +1,9 @@
 import { z } from 'zod';
-import { paramToUrl, responseStringify } from './internal/utils';
+import { responseStringify } from './internal/utils';
+import { blackListSchema, cameraSettingsSchema, flightInfoSchema, mapInfoSchema, priorityListSchema, serverSettingsSchema, trackingModeSchema, whiteListSchema, zonesSchema, } from './types/PlaneTrackerAPI';
 import { ParsingBlobError } from './errors/errors';
 import { ProxyClient } from './internal/ProxyClient';
+import { cameraListSchema } from './types/GenetecAgent';
 const BASE_PATH = '/local/planetracker';
 export class PlaneTrackerAPI {
     client;
@@ -10,13 +12,13 @@ export class PlaneTrackerAPI {
         this.client = client;
         this.apiUser = apiUser;
     }
-    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     getClient(proxyParams) {
         return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
     }
     async checkCameraTime(options) {
-        const response = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
-        return z.boolean().parse(response.state);
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return z.boolean().parse(res.state);
     }
     async resetPtzCalibration(options) {
         const agent = this.getClient(options?.proxyParams);
@@ -47,7 +49,8 @@ export class PlaneTrackerAPI {
         });
     }
     async fetchCameraSettings(options) {
-        return await this._getJson(`${BASE_PATH}/package_camera_settings.cgi`, { action: 'get' }, options);
+        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, {
@@ -55,7 +58,8 @@ export class PlaneTrackerAPI {
         }, options);
     }
     async fetchServerSettings(options) {
-        return await this._getJson(`${BASE_PATH}/package_server_settings.cgi`, { action: 'get' }, options);
+        const res = await this._getJson(`${BASE_PATH}/package_server_settings.cgi`, { action: 'get' }, options);
+        return serverSettingsSchema.parse(res);
     }
     async exportAppSettings(dataType, options) {
         return await this._getBlob(`${BASE_PATH}/package_data.cgi`, { action: 'EXPORT', dataType }, options);
@@ -70,13 +74,15 @@ export class PlaneTrackerAPI {
         });
     }
     async fetchFlightInfo(icao, options) {
-        return await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao: encodeURIComponent(icao) }, options);
+        const res = await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao }, options);
+        return flightInfoSchema.parse(res);
     }
     async getTrackingMode(options) {
-        return await this._getJson(`${BASE_PATH}/package/getTrackingMode.cgi`, undefined, options);
+        const res = await this._getJson(`${BASE_PATH}/package/getTrackingMode.cgi`, undefined, options);
+        return trackingModeSchema.parse(res);
     }
-    async setTrackingMode(modeJsonString, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, modeJsonString, this.apiUser, options);
+    async setTrackingMode(mode, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, { mode }, this.apiUser, options);
     }
     async startTrackingPlane(icao, options) {
         const agent = this.getClient(options?.proxyParams);
@@ -95,31 +101,36 @@ export class PlaneTrackerAPI {
         });
     }
     async getPriorityList(options) {
-        return await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);
+        const res = await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);
+        return priorityListSchema.parse(res);
     }
-    async setPriorityList(priorityListJsonString, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, priorityListJsonString, this.apiUser, options);
+    async setPriorityList(priorityList, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, { priorityList }, this.apiUser, options);
     }
     async getWhiteList(options) {
-        return await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
+        const res = await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
+        return whiteListSchema.parse(res);
     }
-    async setWhiteList(whiteListJsonString, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, whiteListJsonString, this.apiUser, options);
+    async setWhiteList(whiteList, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, { whiteList }, this.apiUser, options);
     }
     async getBlackList(options) {
-        return await this._getJson(`${BASE_PATH}/package/getBlackList.cgi`, undefined, options);
+        const res = await this._getJson(`${BASE_PATH}/package/getBlackList.cgi`, undefined, options);
+        return blackListSchema.parse(res);
     }
-    async setBlackList(blackListJsonString, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, blackListJsonString, this.apiUser, options);
+    async setBlackList(blackList, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, { blackList }, this.apiUser, options);
     }
     async fetchMapInfo(options) {
-        return await this._getJson(`${BASE_PATH}/package/getMapInfo.cgi`, undefined, options);
+        const res = await this._getJson(`${BASE_PATH}/package/getMapInfo.cgi`, undefined, options);
+        return mapInfoSchema.parse(res);
     }
     async getZones(options) {
-        return await this._getJson(`${BASE_PATH}/package/getZones.cgi`, undefined, options);
+        const res = await this._getJson(`${BASE_PATH}/package/getZones.cgi`, undefined, options);
+        return zonesSchema.parse(res);
     }
-    async setZones(zonesJsonString, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, zonesJsonString, this.apiUser, options);
+    async setZones(zones, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, { zones }, this.apiUser, options);
     }
     async goToCoordinates(lat, lon, alt, options) {
         const agent = this.getClient(options?.proxyParams);
@@ -130,19 +141,25 @@ export class PlaneTrackerAPI {
         });
     }
     async checkGenetecConnection(params, options) {
-        return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, params, options);
+        return 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);
-        return await res.json();
+        const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, '', params, options);
+        return cameraListSchema.parse(res);
     }
-    async _getJson(path, parameters, options) {
+    async _getJson(path, parameters, options, headers) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({
-            path,
-            parameters,
-            timeout: options?.timeout,
-        });
+        const res = await agent.get({ path, parameters, timeout: options?.timeout, headers });
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async _post(path, data, parameters, options, headers) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
@@ -152,11 +169,7 @@ export class PlaneTrackerAPI {
     }
     async _getBlob(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({
-            path,
-            parameters,
-            timeout: options?.timeout,
-        });
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await this.parseBlobResponse(res);
         }
@@ -172,36 +185,12 @@ export class PlaneTrackerAPI {
             throw new ParsingBlobError(err);
         }
     }
-    async _postJsonEncoded(path, data, parameters, options) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({
-            path,
-            data,
-            parameters,
-            headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-            timeout: options?.timeout,
-        });
-        if (res.ok) {
-            return res;
-        }
-        else {
-            throw new Error(await responseStringify(res));
-        }
+    async _postUrlEncoded(path, data, parameters, options, headers) {
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        return this._post(path, data, parameters, options, { ...baseHeaders, ...headers });
     }
-    async _postUrlEncoded(path, params, options) {
-        const data = paramToUrl(params);
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({
-            path,
-            data,
-            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-            timeout: options?.timeout,
-        });
-        if (res.ok) {
-            return res;
-        }
-        else {
-            throw new Error(await responseStringify(res));
-        }
+    async _postJsonEncoded(path, data, parameters, options, headers) {
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        return this._post(path, data, parameters, options, { ...baseHeaders, ...headers });
     }
 }

package/esm/VapixAPI.js

@@ -1,5 +1,5 @@
 import { arrayToUrl, isNullish, paramToUrl, responseStringify } from './internal/utils';
-import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, } from './types/VapixAPI';
+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 { ProxyClient } from './internal/ProxyClient';
 import { z } from 'zod';
@@ -107,11 +107,11 @@ export class VapixAPI {
         });
         const result = parser.parse(xmlText);
         const data = result.root.disks.disk;
-        return {
+        return sdCardInfoSchema.parse({
             totalSize: parseInt(data.totalsize),
             freeSize: parseInt(data.freesize),
             status: sdCardWatchedStatuses.includes(data.status) ? data.status : 'disconnected',
-        };
+        });
     }
     mountSDCard(options) {
         return this._doSDCardMountAction('MOUNT', options);
@@ -180,7 +180,7 @@ export class VapixAPI {
         if (isNullish(captureMode.maxFPS)) {
             throw new MaxFPSError('FPS_NOT_SPECIFIED');
         }
-        return captureMode.maxFPS;
+        return z.number().parse(captureMode.maxFPS);
     }
     async getTimezone(options) {
         try {
@@ -204,7 +204,7 @@ export class VapixAPI {
         if (data.data.timeZone === undefined) {
             throw new Error('Time zone not setup on the device');
         }
-        return data.data.timeZone;
+        return z.string().parse(data.data.timeZone);
     }
     async getDateTimeInfo(options) {
         const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
@@ -259,7 +259,7 @@ export class VapixAPI {
         const gTourList = new Array();
         const response = await this.getParameter('GuardTour', options);
         for (let i = 0; i < 20; i++) {
-            const gTourBaseName = 'root.GuardTour.G' + i;
+            const gTourBaseName = 'GuardTour.G' + i;
             if (gTourBaseName + '.CamNbr' in response) {
                 const gTour = {
                     id: gTourBaseName,
@@ -271,7 +271,7 @@ export class VapixAPI {
                     tour: [],
                 };
                 for (let j = 0; j < 100; j++) {
-                    const tourBaseName = 'root.GuardTour.G' + i + '.Tour.T' + j;
+                    const tourBaseName = 'GuardTour.G' + i + '.Tour.T' + j;
                     if (tourBaseName + '.MoveSpeed' in response) {
                         const tour = {
                             moveSpeed: response[tourBaseName + '.MoveSpeed'],
@@ -289,17 +289,17 @@ export class VapixAPI {
                 break;
             }
         }
-        return gTourList;
+        return guardTourSchema.parse(gTourList);
     }
-    setGuardTourEnabled(guardTourID, enable, options) {
+    setGuardTourEnabled(guardTourId, enable, options) {
         const params = {};
-        params[guardTourID + '.Running'] = enable ? 'yes' : 'no';
+        params[guardTourId + '.Running'] = enable ? 'yes' : 'no';
         return this.setParameter(params, options);
     }
     async getPTZPresetList(channel, options) {
         const res = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposcam',
-            camera: channel.toString(),
+            camera: channel,
         }, undefined, options);
         const text = await res.text();
         const lines = text.split(/[\r\n]/);
@@ -313,7 +313,7 @@ export class VapixAPI {
                 }
             }
         }
-        return positions;
+        return z.array(z.string()).parse(positions);
     }
     async listPTZ(camera, options) {
         const url = `/axis-cgi/com/ptz.cgi`;
@@ -347,7 +347,7 @@ export class VapixAPI {
                 res[camera - 1] = item.map(({ data: itemData, ...d }) => d);
             }
         });
-        return res;
+        return ptzOverviewSchema.parse(res);
     }
     goToPreset(channel, presetName, options) {
         return this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
@@ -361,11 +361,11 @@ export class VapixAPI {
             camera: camera.toString(),
         }, undefined, options);
         const params = VapixAPI.parseParameters(await res.text());
-        return {
+        return cameraPTZItemDataSchema.parse({
             pan: Number(params.pan),
             tilt: Number(params.tilt),
             zoom: Number(params.zoom),
-        };
+        });
     }
     async getPorts(options) {
         const res = await this.postJson('/axis-cgi/io/portmanagement.cgi', {
@@ -373,7 +373,7 @@ export class VapixAPI {
             context: '',
             method: 'getPorts',
         }, undefined, options);
-        const portResponseParsed = await getPortsResponseSchema.parse(res.json());
+        const portResponseParsed = getPortsResponseSchema.parse(await res.json());
         return portResponseParsed.data.items;
     }
     async setPorts(ports, options) {
@@ -406,19 +406,20 @@ export class VapixAPI {
         if (!Array.isArray(apps)) {
             apps = [apps];
         }
-        return apps.map((app) => {
+        const appList = apps.map((app) => {
             return {
                 ...app,
                 appId: APP_IDS.find((id) => id.toLowerCase() === app.Name.toLowerCase()) ?? null,
             };
         });
+        return applicationListSchema.parse(appList);
     }
-    async startApplication(applicationID, options) {
+    async startApplication(applicationId, options) {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({
             path: '/axis-cgi/applications/control.cgi',
             parameters: {
-                package: applicationID.toLowerCase(),
+                package: applicationId.toLowerCase(),
                 action: 'start',
             },
             timeout: options?.timeout,
@@ -428,12 +429,12 @@ export class VapixAPI {
             throw new ApplicationAPIError('START', await responseStringify(res));
         }
     }
-    async restartApplication(applicationID, options) {
+    async restartApplication(applicationId, options) {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({
             path: '/axis-cgi/applications/control.cgi',
             parameters: {
-                package: applicationID.toLowerCase(),
+                package: applicationId.toLowerCase(),
                 action: 'restart',
             },
             timeout: options?.timeout,
@@ -443,12 +444,12 @@ export class VapixAPI {
             throw new ApplicationAPIError('RESTART', await responseStringify(res));
         }
     }
-    async stopApplication(applicationID, options) {
+    async stopApplication(applicationId, options) {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({
             path: '/axis-cgi/applications/control.cgi',
             parameters: {
-                package: applicationID.toLowerCase(),
+                package: applicationId.toLowerCase(),
                 action: 'stop',
             },
             timeout: options?.timeout,

package/esm/{CamOverlayDrawingAPI.js → node/CamOverlayDrawingAPI.js}

@@ -1,5 +1,5 @@
 import EventEmitter from 'events';
-import { WsClient } from './node/WsClient';
+import { WsClient } from './WsClient';
 export class CamOverlayDrawingAPI extends EventEmitter {
     tls;
     tlsInsecure;

package/esm/{CamOverlayPainter → node/CamOverlayPainter}/Painter.js

@@ -1,17 +1,7 @@
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
 import { ResourceManager } from './ResourceManager';
 import { Frame } from './Frame';
-export const COORD = {
-    top_left: [-1, -1],
-    center_left: [-1, 0],
-    bottom_left: [-1, 1],
-    top_center: [0, -1],
-    center: [0, 0],
-    bottom_center: [0, 1],
-    top_right: [1, -1],
-    center_right: [1, 0],
-    bottom_right: [1, 1],
-};
+import { COORD } from '../../types/CamOverlayPainter';
 export class Painter extends Frame {
     screenWidth;
     screenHeight;

package/esm/{CamScripterAPICameraEventsGenerator.js → node/CamScripterAPICameraEventsGenerator.js}

@@ -1,5 +1,5 @@
 import EventEmitter from 'events';
-import { WsClient } from './node/WsClient';
+import { WsClient } from './WsClient';
 export class CamScripterAPICameraEventsGenerator extends EventEmitter {
     tls;
     tlsInsecure;

package/esm/{VapixEvents.js → node/VapixEvents.js}

@@ -1,5 +1,5 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { WsClient } from './node/WsClient';
+import { WsClient } from './WsClient';
 export class VapixEvents extends EventEmitter {
     tls;
     tlsInsecure;

package/esm/node/events/GenetecAgent.js

@@ -1,27 +1,5 @@
-import { z } from 'zod';
 import { responseStringify, pad } from '../../internal/utils';
-const successResponseSchema = z.object({
-    Rsp: z.object({
-        Status: z.literal('Ok'),
-    }),
-});
-const cameraGuidsResponseSchema = z.object({
-    Rsp: z.object({
-        Status: z.literal('Ok'),
-        Result: z.array(z.object({ Guid: z.string() })),
-    }),
-});
-const cameraDetailSchema = z.object({
-    Guid: z.string().optional(),
-    Name: z.string().optional(),
-    EntityType: z.string().optional(),
-});
-const cameraDetailsResponseSchema = z.object({
-    Rsp: z.object({
-        Status: z.literal('Ok'),
-        Result: z.union([z.array(cameraDetailSchema), cameraDetailSchema]),
-    }),
-});
+import { cameraDetailsResponseSchema, cameraGuidsResponseSchema, successResponseSchema, } from '../../types/GenetecAgent';
 export class GenetecAgent {
     settings;
     baseUrl;

package/esm/node/index.js

@@ -3,3 +3,13 @@ export * from './WsClient';
 export * from './HttpServer';
 export * from './events/AxisCameraStationEvents';
 export * from './events/GenetecAgent';
+export { ResourceManager } from './CamOverlayPainter/ResourceManager';
+export { Painter } from './CamOverlayPainter/Painter';
+export { Frame } from './CamOverlayPainter/Frame';
+export * from '../types/CamOverlayPainter';
+export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
+export * from '../types/CamOverlayDrawingAPI';
+export { CamScripterAPICameraEventsGenerator } from './CamScripterAPICameraEventsGenerator';
+export * from '../types/CamScripterAPICameraEventsGenerator';
+export { VapixEvents } from './VapixEvents';
+export * from '../types/VapixEvents';

package/esm/types/CamOverlayAPI/CamOverlayAPI.js

@@ -9,7 +9,7 @@ import { customGraphicsSchema } from './customGraphicsSchema';
 import { screenSharingSchema } from './screenSharingSchema';
 import { webCameraSharingSchema } from './webCameraSharingSchema';
 import { baseballScoreBoardAutomaticSchema, baseballScoreBoardSchema, scoreBoardSchema, scoreOverviewSchema, } from './scoreBoardSchema';
-export const WSResponseSchema = z.object({
+export const wsResponseSchema = z.object({
     status: z.number(),
     message: z.string(),
 });

package/esm/types/CamOverlayAPI/scoreBoardSchema.js

@@ -1,6 +1,11 @@
 import { z } from 'zod';
 import { coordinateSystemSchema, serviceNames } from './serviceCommonTypes';
-export const sportFontSchema = z.union([z.literal('classic'), z.intersection(z.string(), z.object({}))]);
+export const sportFontSchema = z.union([
+    z.literal('classic'),
+    z.custom((val) => {
+        return typeof val === 'string';
+    }),
+]);
 export const scoreBoardSchema = z.object({
     id: z.number().nonnegative(),
     enabled: z.union([z.literal(0), z.literal(1)]),

package/esm/types/CamOverlayPainter.js

@@ -1 +1,11 @@
-export {};
+export const COORD = {
+    top_left: [-1, -1],
+    center_left: [-1, 0],
+    bottom_left: [-1, 1],
+    top_center: [0, -1],
+    center: [0, 0],
+    bottom_center: [0, 1],
+    top_right: [1, -1],
+    center_right: [1, 0],
+    bottom_right: [1, 1],
+};

package/esm/types/CamSwitcherAPI.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { toCamelCase, toCamelCaseDeep } from '../internal/transformers';
-import { storageTypeSchema, keyboardShortcutsSchema, h264ProfileSchema, audioChannelCountSchema, } from './common';
+import { storageTypeSchema, keyboardShortcutsSchema, h264ProfileSchema, audioChannelCountSchema, keyboardShortcutSchema, } from './common';
 const channelTypeSchema = z.union([z.literal('audio'), z.literal('video'), z.literal('av')]);
 const playlistPlayTypeSchema = z.union([
     z.literal('PLAY_ALL'),
@@ -132,3 +132,40 @@ export const clipListSchema = z.object({
         ])),
     })),
 });
+export const bitrateModeSchema = z.union([z.literal('VBR'), z.literal('MBR'), z.literal('ABR')]);
+export const bitrateVapixParamsSchema = z.object({
+    bitrateMode: bitrateModeSchema,
+    maximumBitRate: z.number(),
+    retentionTime: z.number(),
+    bitRateLimit: z.number(),
+});
+export const cameraOptionsSchema = bitrateVapixParamsSchema
+    .extend({
+    resolution: z.string(),
+    h264Profile: h264ProfileSchema,
+    fps: z.number(),
+    compression: z.number().min(0).max(100),
+    govLength: z.number(),
+    bitrateVapixParams: z.string().nullable(),
+    audioSampleRate: z.number(),
+    audioChannelCount: audioChannelCountSchema,
+    keyboard: z.object({
+        fromSource: keyboardShortcutSchema,
+        none: keyboardShortcutSchema,
+    }),
+})
+    .partial();
+export const globalAudioSettingsTypeSchema = z.union([z.literal('fromSource'), z.literal('source')]);
+export const globalAudioSettingsSchema = z.object({
+    type: globalAudioSettingsTypeSchema,
+    source: z.string(),
+    storage: z.string().optional(),
+});
+export const secondaryAudioSettingsSchema = z.object({
+    type: z.union([z.literal('CLIP'), z.literal('STREAM'), z.literal('NONE')]),
+    streamName: z.string().optional(),
+    clipName: z.string().optional(),
+    storage: storageTypeSchema,
+    secondaryAudioLevel: z.number(),
+    masterAudioLevel: z.number(),
+});

package/esm/types/GenetecAgent.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const successResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+    }),
+});
+export const cameraGuidsResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+        Result: z.array(z.object({ Guid: z.string() })),
+    }),
+});
+export const cameraDetailSchema = z.object({
+    Guid: z.string().optional(),
+    Name: z.string().optional(),
+    EntityType: z.string().optional(),
+});
+export const cameraDetailsResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+        Result: z.union([z.array(cameraDetailSchema), cameraDetailSchema]),
+    }),
+});
+export const cameraListSchema = z.array(z.object({
+    index: z.number(),
+    value: z.string(),
+    label: z.string(),
+}));