camstreamerlib 4.0.0-beta.33 → 4.0.0-beta.35

package/esm/PlaneTrackerAPI.js

@@ -18,49 +18,49 @@ export class PlaneTrackerAPI {
         const response = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
         return z.boolean().parse(response.state);
     }
-    resetPtzCalibration = async (options) => {
+    async resetPtzCalibration(options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/resetPtzCalibration.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
         });
-    };
-    resetFocusCalibration = async (options) => {
+    }
+    async resetFocusCalibration(options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/resetFocusCalibration.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
         });
-    };
-    serverRunCheck = async (options) => {
+    }
+    async serverRunCheck(options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({ path: `${BASE_PATH}/package/serverRunCheck.cgi`, timeout: options?.timeout });
-    };
-    getLiveViewAlias = async (rtspUrl, options) => {
+    }
+    async getLiveViewAlias(rtspUrl, options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/getLiveViewAlias.cgi`,
             parameters: { rtsp_url: rtspUrl },
             timeout: options?.timeout,
         });
-    };
-    fetchCameraSettings = async (options) => {
+    }
+    async fetchCameraSettings(options) {
         return await this._getJson(`${BASE_PATH}/package_camera_settings.cgi`, { action: 'get' }, options);
-    };
-    setCameraSettings = async (settingsJsonString, options) => {
+    }
+    async setCameraSettings(settingsJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settingsJsonString, {
             action: 'set',
         }, options);
-    };
-    fetchServerSettings = async (options) => {
+    }
+    async fetchServerSettings(options) {
         return await this._getJson(`${BASE_PATH}/package_server_settings.cgi`, { action: 'get' }, options);
-    };
-    exportAppSettings = async (dataType, options) => {
+    }
+    async exportAppSettings(dataType, options) {
         return await this._getBlob(`${BASE_PATH}/package_data.cgi`, { action: 'EXPORT', dataType }, options);
-    };
-    importAppSettings = async (dataType, formData, options) => {
+    }
+    async importAppSettings(dataType, formData, options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.post({
             path: `${BASE_PATH}/package_data.cgi`,
@@ -68,74 +68,74 @@ export class PlaneTrackerAPI {
             parameters: { action: 'IMPORT', dataType },
             timeout: options?.timeout,
         });
-    };
-    fetchFlightInfo = async (icao, options) => {
+    }
+    async fetchFlightInfo(icao, options) {
         return await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao: encodeURIComponent(icao) }, options);
-    };
-    getTrackingMode = async (options) => {
+    }
+    async getTrackingMode(options) {
         return await this._getJson(`${BASE_PATH}/package/getTrackingMode.cgi`, undefined, options);
-    };
-    setTrackingMode = async (modeJsonString, options) => {
+    }
+    async setTrackingMode(modeJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, modeJsonString, this.apiUser, options);
-    };
-    startTrackingPlane = async (icao, options) => {
+    }
+    async startTrackingPlane(icao, options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/trackIcao.cgi`,
             parameters: { icao, ...this.apiUser },
             timeout: options?.timeout,
         });
-    };
-    stopTrackingPlane = async (options) => {
+    }
+    async stopTrackingPlane(options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/resetIcao.cgi`,
             parameters: this.apiUser,
             timeout: options?.timeout,
         });
-    };
-    getPriorityList = async (options) => {
+    }
+    async getPriorityList(options) {
         return await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);
-    };
-    setPriorityList = async (priorityListJsonString, options) => {
+    }
+    async setPriorityList(priorityListJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, priorityListJsonString, this.apiUser, options);
-    };
-    getWhiteList = async (options) => {
+    }
+    async getWhiteList(options) {
         return await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
-    };
-    setWhiteList = async (whiteListJsonString, options) => {
+    }
+    async setWhiteList(whiteListJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, whiteListJsonString, this.apiUser, options);
-    };
-    getBlackList = async (options) => {
+    }
+    async getBlackList(options) {
         return await this._getJson(`${BASE_PATH}/package/getBlackList.cgi`, undefined, options);
-    };
-    setBlackList = async (blackListJsonString, options) => {
+    }
+    async setBlackList(blackListJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, blackListJsonString, this.apiUser, options);
-    };
-    fetchMapInfo = async (options) => {
+    }
+    async fetchMapInfo(options) {
         return await this._getJson(`${BASE_PATH}/package/getMapInfo.cgi`, undefined, options);
-    };
-    getZones = async (options) => {
+    }
+    async getZones(options) {
         return await this._getJson(`${BASE_PATH}/package/getZones.cgi`, undefined, options);
-    };
-    setZones = async (zonesJsonString, options) => {
+    }
+    async setZones(zonesJsonString, options) {
         return await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, zonesJsonString, this.apiUser, options);
-    };
-    goToCoordinates = async (lat, lon, alt, options) => {
+    }
+    async goToCoordinates(lat, lon, alt, options) {
         const agent = this.getClient(options?.proxyParams);
         return await agent.get({
             path: `${BASE_PATH}/package/goToCoordinates.cgi`,
             parameters: { lat, lon, alt, ...this.apiUser },
             timeout: options?.timeout,
         });
-    };
-    checkGenetecConnection = async (params, options) => {
+    }
+    async checkGenetecConnection(params, options) {
         return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, params, options);
-    };
-    getGenetecCameraList = async (params, options) => {
+    }
+    async getGenetecCameraList(params, options) {
         const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, params, options);
         return await res.json();
-    };
+    }
     async _getJson(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({

package/esm/VapixAPI.js

@@ -1,4 +1,3 @@
-import * as prettifyXml from 'prettify-xml';
 import { arrayToUrl, isNullish, paramToUrl, responseStringify } from './internal/utils';
 import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, } from './types/VapixAPI';
 import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, SDCardActionError, SDCardJobError, } from './errors/errors';
@@ -7,8 +6,10 @@ import { z } from 'zod';
 import { XMLParser } from 'fast-xml-parser';
 export class VapixAPI {
     client;
-    constructor(client) {
+    CustomFormData;
+    constructor(client, CustomFormData = FormData) {
         this.client = client;
+        this.CustomFormData = CustomFormData;
     }
     getClient(proxyParams) {
         return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
@@ -35,7 +36,11 @@ export class VapixAPI {
     }
     async getCameraImage(parameters, options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({ path: '/axis-cgi/jpg/image.cgi', parameters, timeout: options?.timeout });
+        return (await agent.get({
+            path: '/axis-cgi/jpg/image.cgi',
+            parameters,
+            timeout: options?.timeout,
+        }));
     }
     async getEventDeclarations(options) {
         const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
@@ -53,8 +58,7 @@ export class VapixAPI {
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
-        const declarations = await res.text();
-        return prettifyXml(declarations);
+        return await res.text();
     }
     async getSupportedAudioSampleRate(options) {
         const path = '/axis-cgi/audio/streamingcapabilities.cgi';
@@ -250,7 +254,6 @@ export class VapixAPI {
         if (responseText.startsWith('# Error')) {
             throw new Error(responseText);
         }
-        return true;
     }
     async getGuardTourList(options) {
         const gTourList = new Array();
@@ -455,7 +458,7 @@ export class VapixAPI {
         }
     }
     async installApplication(data, fileName, options) {
-        const formData = new FormData();
+        const formData = new this.CustomFormData();
         formData.append('packfil', data, fileName);
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({

package/esm/index.js

@@ -2,6 +2,7 @@ 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 { CamSwitcherAPI } from './CamSwitcherAPI';
 export { CamSwitcherEvents } from './CamSwitcherEvents';
@@ -15,9 +16,3 @@ export * from './types/CamSwitcherAPI';
 export * from './types/VapixAPI';
 export * from './types/CamOverlayAPI';
 export * from './types/PlaneTrackerAPI';
-export { Frame } from './CamOverlayPainter/Frame';
-export { Painter } from './CamOverlayPainter/Painter';
-export { ResourceManager } from './CamOverlayPainter/ResourceManager';
-export * from './types/CamOverlayPainter';
-export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
-export * from './types/CamOverlayDrawingAPI';

package/esm/internal/ProxyClient.js

@@ -6,19 +6,19 @@ export class ProxyClient {
         this.client = client;
         this.proxyParams = proxyParams;
     }
-    get = (params) => {
+    get(params) {
         const { path, parameters, headers, timeout } = params;
         const targetPath = addParametersToPath(path, parameters);
         const { realPath, realHeaders } = this.getReal(targetPath, headers);
         return this.client.get({ path: realPath, headers: realHeaders, timeout });
-    };
-    post = (params) => {
+    }
+    post(params) {
         const { path, data, parameters, headers, timeout } = params;
         const targetPath = addParametersToPath(path, parameters);
         const { realPath, realHeaders } = this.getReal(targetPath, headers);
         return this.client.post({ path: realPath, data, headers: realHeaders, timeout });
-    };
-    getReal = (targetPath, headers) => {
+    }
+    getReal(targetPath, headers) {
         return {
             realPath: this.proxyParams.path,
             realHeaders: {
@@ -32,5 +32,5 @@ export class ProxyClient {
                 'x-target-camera-user': this.proxyParams.target.user,
             },
         };
-    };
+    }
 }

package/esm/internal/WsEvents.js

@@ -0,0 +1,68 @@
+export class WsEvents {
+    zodSchema;
+    ws;
+    _isDestroyed = false;
+    listeners = {};
+    constructor(zodSchema, ws) {
+        this.zodSchema = zodSchema;
+        this.ws = ws;
+        this.ws.onmessage = (e) => this.onMessage(e);
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    resendInitData() {
+        const request = {
+            command: 'sendInitData',
+        };
+        this.ws.send(JSON.stringify(request));
+    }
+    addListener(type, listener, id) {
+        const typeList = this.listeners[type];
+        if (typeList === undefined) {
+            this.listeners[type] = { [id]: listener };
+            return;
+        }
+        typeList[id] = listener;
+    }
+    removeListener(type, id) {
+        const typeList = this.listeners[type];
+        if (typeList) {
+            delete typeList[id];
+            if (Object.keys(typeList).length === 0) {
+                delete this.listeners[type];
+            }
+        }
+    }
+    onMessage(evt) {
+        if (this.isDestroyed) {
+            return;
+        }
+        try {
+            const eventData = JSON.parse(evt.data);
+            const data = this.zodSchema.parse(eventData);
+            if (isInitEvent(data)) {
+                this.processMessage(data.data, true);
+                return;
+            }
+            this.processMessage(data, false);
+        }
+        catch (error) {
+            console.error('Error parsing event data:', evt.data, error);
+        }
+    }
+    processMessage(event, isInit) {
+        const listeners = this.listeners[event.type];
+        const list = Object.values(listeners ?? {});
+        list.forEach((listener) => listener(event, isInit));
+    }
+    destroy() {
+        this._isDestroyed = true;
+        this.ws.onmessage = () => { };
+        this.ws.destroy();
+        this.listeners = {};
+    }
+}
+const isInitEvent = (event) => {
+    return event.type === 'init';
+};

package/esm/node/DefaultClient.js

@@ -22,16 +22,16 @@ export class DefaultClient {
         }
         this.httpRequestSender = new HttpRequestSender(agentOptions);
     }
-    get = (params) => {
+    get(params) {
         const { path, parameters, headers, timeout } = params;
         const options = this.getBaseConnectionParams('GET', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options);
-    };
-    post = (params) => {
+    }
+    post(params) {
         const { path, data, parameters, headers, timeout } = params;
         const options = this.getBaseConnectionParams('POST', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options, data);
-    };
+    }
     getBaseConnectionParams(method, path, params, headers, timeout) {
         return {
             method: method,

package/esm/node/HttpRequestSender.js

@@ -1,4 +1,4 @@
-import { Digest } from '../internal/Digest';
+import { Digest } from './Digest';
 import { Agent, fetch as undiciFetch, Request as UndiciRequest, } from 'undici';
 export class HttpRequestSender {
     agent;

package/esm/node/WsClient.js

@@ -1,6 +1,6 @@
 import * as EventEmitter from 'events';
 import * as WebSocket from 'ws';
-import { Digest } from '../internal/Digest';
+import { Digest } from './Digest';
 export class WsClient extends EventEmitter {
     user;
     pass;

package/esm/{events → node/events}/AxisCameraStationEvents.js

@@ -1,6 +1,6 @@
-import { pad } from '../internal/utils';
-import { ProxyClient } from '../internal/ProxyClient';
-import { DefaultClient } from '../node';
+import { pad } from '../../internal/utils';
+import { ProxyClient } from '../../internal/ProxyClient';
+import { DefaultClient } from '../DefaultClient';
 export class AxisCameraStationEvents {
     sourceKey;
     client;

package/esm/{events → node/events}/GenetecAgent.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { responseStringify, pad } from '../internal/utils';
+import { responseStringify, pad } from '../../internal/utils';
 const successResponseSchema = z.object({
     Rsp: z.object({
         Status: z.literal('Ok'),

package/esm/node/index.js

@@ -1,5 +1,5 @@
 export * from './DefaultClient';
 export * from './WsClient';
 export * from './HttpServer';
-export * from '../events/AxisCameraStationEvents';
-export * from '../events/GenetecAgent';
+export * from './events/AxisCameraStationEvents';
+export * from './events/GenetecAgent';

package/esm/types/CamOverlayAPI/CamOverlayAPI.js

@@ -8,10 +8,10 @@ import { pipSchema } from './pipSchema';
 import { customGraphicsSchema } from './customGraphicsSchema';
 import { screenSharingSchema } from './screenSharingSchema';
 import { webCameraSharingSchema } from './webCameraSharingSchema';
+import { baseballScoreBoardAutomaticSchema, baseballScoreBoardSchema, scoreBoardSchema, scoreOverviewSchema, } from './scoreBoardSchema';
 export const WSResponseSchema = z.object({
     status: z.number(),
     message: z.string(),
-    data: z.string(),
 });
 export const widgetsSchema = z.discriminatedUnion('name', [
     infoTickerSchema,
@@ -23,6 +23,10 @@ export const widgetsSchema = z.discriminatedUnion('name', [
     customGraphicsSchema,
     screenSharingSchema,
     webCameraSharingSchema,
+    scoreBoardSchema,
+    baseballScoreBoardSchema,
+    baseballScoreBoardAutomaticSchema,
+    scoreOverviewSchema,
 ]);
 export const widgetListSchema = z.object({
     services: z.array(widgetsSchema),
@@ -36,6 +40,10 @@ export const isPtzCompass = (widget) => widget.name === 'ptzCompass';
 export const isPtz = (widget) => widget.name === 'ptz';
 export const isScreenSharing = (widget) => widget.name === 'screenSharing';
 export const isWebCameraSharing = (widget) => widget.name === 'web_camera';
+export const isScoreBoard = (widget) => widget.name === 'scoreBoard';
+export const isBaseballScoreBoard = (widget) => widget.name === 'baseballScoreBoard';
+export const isBaseballScoreBoardAutomatic = (widget) => widget.name === 'myBallBaseballWidgets';
+export const isScoreOverview = (widget) => widget.name === 'scoreOverview';
 export var ImageType;
 (function (ImageType) {
     ImageType[ImageType["PNG"] = 0] = "PNG";

package/esm/types/CamOverlayAPI/scoreBoardSchema.js

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { coordinateSystemSchema } from './widgetCommonTypes';
+export const sportFontSchema = z.union([z.literal('classic'), z.intersection(z.string(), z.object({}))]);
+export const scoreBoardSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal('scoreBoard'),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    teamHomeShortname: z.string(),
+    teamGuestShortname: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeImgPath: z.string(),
+    teamGuestImgPath: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    baseTimeTimestamp: z.number(),
+    baseTimePlaytime: z.number(),
+    currentPeriodPlaytime: z.number(),
+    timeIsRunning: z.boolean(),
+    currentPeriodLength: z.number(),
+    currentPeriod: z.number(),
+    font: sportFontSchema.default('classic'),
+});
+export const baseballScoreBoardSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal('baseballScoreBoard'),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    matchFinished: z.boolean(),
+    bases: z.tuple([z.boolean(), z.boolean(), z.boolean()]),
+    homeInning: z.boolean(),
+    inning: z.number().nonnegative(),
+    outs: z.number().nonnegative(),
+    balls: z.number().nonnegative(),
+    strikes: z.number().nonnegative(),
+    baseTimeTimestamp: z.number(),
+    baseTimePlaytime: z.number(),
+    timeIsRunning: z.boolean(),
+    teamHomeShortname: z.string(),
+    teamGuestShortname: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    footerImgPath: z.string().optional(),
+    footerText: z.string().optional(),
+    footerBackgroundColor: z.string().optional(),
+    footerTextColor: z.string().optional(),
+    font: sportFontSchema.default('classic'),
+});
+export const baseballScoreBoardAutomaticSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal('myBallBaseballWidgets'),
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    matchDetailLink: z.string(),
+    matchListLink: z.string(),
+    mirrored: z.boolean(),
+    pregameWidgetText: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    homeLogoPath: z.string(),
+    guestLogoPath: z.string(),
+    footerImgPath: z.string().optional(),
+    footerText: z.string().optional(),
+    footerBackgroundColor: z.string().optional(),
+    footerTextColor: z.string().optional(),
+    font: sportFontSchema.default('classic'),
+});
+export const scoreOverviewSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal('scoreOverview'),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    teamHomeName: z.string(),
+    teamGuestName: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeImgPath: z.string(),
+    teamGuestImgPath: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    scoreVisible: z.boolean(),
+    description: z.string(),
+    textFont: sportFontSchema.default('classic'),
+    scoreFont: z.literal('classic'),
+});

package/esm/types/CamStreamerAPI.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export const streamAttributesSchema = z.object({
+export const cameraStreamSchema = z.object({
     enabled: z.string(),
     active: z.string(),
     audioSource: z.string(),
@@ -22,7 +22,34 @@ export const streamAttributesSchema = z.object({
     startTime: z.string(),
     stopTime: z.string(),
 });
-export const streamListSchema = z.record(z.string(), streamAttributesSchema);
+export const streamSchema = z.object({
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    active: z.union([z.literal(0), z.literal(1)]),
+    audioSource: z.string(),
+    avSyncMsec: z.number().int(),
+    internalVapixParameters: z.string(),
+    userVapixParameters: z.string(),
+    outputParameters: z.string(),
+    outputType: z.union([z.literal('video'), z.literal('images'), z.literal('none')]),
+    mediaServerUrl: z.string(),
+    inputType: z.union([z.literal('CSw'), z.literal('CRS'), z.literal('RTSP_URL')]),
+    inputUrl: z.string(),
+    forceStereo: z.union([z.literal(0), z.literal(1)]),
+    streamDelay: z.number().nullable(),
+    statusLed: z.number(),
+    statusPort: z.string(),
+    callApi: z.number().int(),
+    trigger: z.string(),
+    schedule: z.string(),
+    prepareAhead: z.number().int(),
+    startTime: z.number().nullable(),
+    stopTime: z.number().nullable(),
+});
+export const cameraStreamResponseSchema = z.object({
+    data: cameraStreamSchema,
+    code: z.number(),
+    message: z.string(),
+});
 export const camstreamerServerResponseSchema = z.object({
     code: z.number(),
     message: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.33",
+    "version": "4.0.0-beta.35",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {
@@ -11,7 +11,6 @@
         "eventemitter2": "^5.0.1",
         "fast-xml-parser": "^5.2.5",
         "lodash": "^4.17.21",
-        "prettify-xml": "^1.2.0",
         "type-fest": "^4.41.0",
         "undici": "^6.21.3",
         "ws": "^8.18.0",
@@ -55,6 +54,27 @@
         "/**/*.js",
         "/**/*.ts"
     ],
+    "type": "module",
+    "main": "./cjs/index.js",
+    "module": "./esm/index.js",
+    "types": "types/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./esm/index.js",
+            "require": "./cjs/index.js",
+            "types": "./types/index.d.ts"
+        },
+        "./web": {
+            "import": "./esm/web/index.js",
+            "require": "./cjs/web/index.js",
+            "types": "./types/web/index.d.ts"
+        },
+        "./node": {
+            "import": "./esm/node/index.js",
+            "require": "./cjs/node/index.js",
+            "types": "./types/node/index.d.ts"
+        }
+    },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/CamStreamer/CamStreamerLib.git"