camstreamerlib 4.0.0-beta.4 → 4.0.0-beta.40

package/esm/CamOverlayAPI.js

@@ -1,65 +1,79 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { fileListSchema, ImageType, serviceSchema, storageSchema, } from './types/CamOverlayAPI';
-import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
+import { paramToUrl, responseStringify } from './internal/utils';
+import { ParsingBlobError, ServiceNotFoundError, StorageDataFetchError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
+import { z } from 'zod';
+import { ProxyClient } from './internal/ProxyClient';
+import { fileListSchema, ImageType, storageDataListSchema, serviceListSchema, servicesSchema, wsResponseSchema, } from './types/CamOverlayAPI';
+const BASE_PATH = '/local/camoverlay/api';
 export class CamOverlayAPI {
     client;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
+    constructor(client) {
+        this.client = client;
+    }
+    static getBasePath = () => BASE_PATH;
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getFilePreviewPath = (path) => `${BASE_PATH}/image.cgi?path=${encodeURIComponent(path)}`;
+    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.state);
+    }
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return networkCameraListSchema.parse(res.camera_list);
+    }
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        return wsResponseSchema.parse(res).message;
+    }
+    async getMjpegStreamImage(mjpegUrl, options) {
+        return await this._getBlob(`${BASE_PATH}/fetch_mjpeg_image.cgi`, { mjpeg_url: decodeURIComponent(mjpegUrl) }, options);
+    }
+    async listFiles(fileType, options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'list' }, options);
+        return fileListSchema.parse(res.list);
+    }
+    async uploadFile(fileType, formData, storage, options) {
+        await this._post(`${BASE_PATH}/upload_${fileType}.cgi`, formData, {
+            action: 'upload',
+            storage: storage,
+        }, options);
+    }
+    async removeFile(fileType, fileParams, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/upload_${fileType}.cgi`, {
+            action: 'remove',
+            ...fileParams,
+        }, options, undefined);
+    }
+    async getFileStorage(fileType, options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'get_storage' }, options);
+        if (res.code !== 200) {
+            throw new StorageDataFetchError(res);
         }
-        else {
-            this.client = new DefaultClient(options);
-        }
-    }
-    async checkCameraTime() {
-        const cameraTime = await this.get('/local/camoverlay/api/camera_time.cgi');
-        return cameraTime.state;
-    }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camoverlay/api/network_camera_list.cgi');
-        return networkCameraListSchema.parse(response.camera_list);
-    }
-    async wsAutoratization() {
-        const response = await this.get(`/local/camoverlay/api/ws_authorization.cgi`);
-        return response.data;
-    }
-    async getMjpegStreamImage(mjpegUrl) {
-        const res = await this.get(`/local/camoverlay/api/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
-        return await this.parseBlobResponse(res);
+        return storageDataListSchema.parse(res.list);
     }
-    async listFiles(fileType) {
-        const files = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=list`);
-        return fileListSchema.parse(files.list);
+    async getFilePreviewFromCamera(path, options) {
+        return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path), undefined, options);
     }
-    async uploadFile(fileType, file, fileName) {
-        const formData = new FormData();
-        formData.append('target', 'SD0');
-        formData.append('uploadedFile[]', file, fileName);
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=upload`;
-        await this.post(path, formData);
+    async updateInfoticker(serviceId, text, options) {
+        await this._getJson(`${BASE_PATH}/infoticker.cgi`, { service_id: serviceId, text: text }, options);
     }
-    async removeFile(fileType, file) {
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=remove`;
-        await this.post(path, JSON.stringify(file));
+    async setEnabled(serviceId, enabled, options) {
+        await this._post(`${BASE_PATH}/enabled.cgi`, '', { [`id_${serviceId}`]: enabled ? 1 : 0 }, options);
     }
-    async getFileStorage(fileType) {
-        const data = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=get_storage`);
-        return storageSchema.parse(data);
-    }
-    async updateInfoticker(serviceID, text) {
-        await this.get(`/local/camoverlay/api/infoticker.cgi?service_id=${serviceID}&text=${text}`);
-    }
-    async setEnabled(serviceID, enabled) {
-        await this.post(`/local/camoverlay/api/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
-    }
-    async isEnabled(serviceID) {
-        const res = await this.client.get('/local/camoverlay/api/services.cgi?action=get');
+    async isEnabled(serviceId, options) {
+        const agent = this.getClient(options?.proxyParams);
+        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) {
-                if (service.id === serviceID) {
+                if (service.id === serviceId) {
                     return service.enabled === 1;
                 }
             }
@@ -69,29 +83,30 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async getSingleService(serviceId) {
-        const data = await this.get('/local/camoverlay/api/services.cgi', {
+    async getSingleService(serviceId, options) {
+        const res = await this._getJson(`${BASE_PATH}/services.cgi`, {
             action: 'get',
-            service_id: serviceId.toString(),
-        });
-        return serviceSchema.parse(data);
+            service_id: serviceId,
+        }, options);
+        return servicesSchema.parse(res);
     }
-    async getServices() {
-        const serviceList = await this.get('/local/camoverlay/api/services.cgi?action=get');
-        return serviceSchema.parse(serviceList).services;
+    async getServices(options) {
+        const res = await this._getJson(`${BASE_PATH}/services.cgi`, { action: 'get' }, options);
+        const services = serviceListSchema.parse(res).services;
+        return services;
     }
-    async updateSingleService(serviceId, serviceJson) {
-        const path = '/local/camoverlay/api/services.cgi';
-        await this.post(path, JSON.stringify(serviceJson), {
+    async updateSingleService(service, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify(service), {
             action: 'set',
-            service_id: serviceId.toString(),
-        });
+            service_id: service.id,
+        }, options, undefined);
     }
-    async updateServices(servicesJson) {
-        const path = '/local/camoverlay/api/services.cgi?action=set';
-        await this.post(path, JSON.stringify(servicesJson));
+    async updateServices(services, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify({ services: services }), {
+            action: 'set',
+        }, options, undefined);
     }
-    updateCGText(serviceID, fields) {
+    updateCGText(serviceId, fields, options) {
         const params = {};
         for (const field of fields) {
             const name = field.field_name;
@@ -100,51 +115,59 @@ export class CamOverlayAPI {
                 params[`${name}_color`] = field.color;
             }
         }
-        return this.promiseCGUpdate(serviceID, 'update_text', params);
+        return this.promiseCGUpdate(serviceId, 'update_text', params, undefined, undefined, options);
     }
-    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
+    updateCGImagePos(serviceId, coordinates = '', x = 0, y = 0, options) {
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, undefined, undefined, options);
     }
-    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
+    updateCGImage(serviceId, path, coordinates = '', x = 0, y = 0, options) {
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
             image: path,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, undefined, undefined, options);
     }
-    updateCGImageFromData(serviceID, imageType, imageData, coordinates = '', x = 0, y = 0) {
+    updateCGImageFromData(serviceId, imageType, imageData, coordinates = '', x = 0, y = 0, options) {
         const contentType = imageType === ImageType.PNG ? 'image/png' : 'image/jpeg';
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params, contentType, imageData);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, contentType, imageData, options);
     }
-    async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
-        const path = `/local/camoverlay/api/customGraphics.cgi`;
+    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 res = await this.client.post(path, data ?? '', {
-            action: action,
-            service_id: serviceID.toString(),
-            ...params,
-        }, headers);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data: data ?? '',
+            parameters: {
+                action: action,
+                service_id: serviceId.toString(),
+                ...params,
+            },
+            headers,
+            timeout: options?.timeout,
+        });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async _getJson(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
@@ -152,8 +175,9 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async post(path, data, params) {
-        const res = await this.client.post(path, data, params);
+    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();
         }
@@ -161,12 +185,31 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
+    async _getBlob(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
     async parseBlobResponse(response) {
         try {
-            return await response.blob();
+            return (await response.blob());
         }
         catch (err) {
             throw new ParsingBlobError(err);
         }
     }
+    async _postUrlEncoded(path, parameters, options, headers) {
+        const data = paramToUrl(parameters);
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        return this._post(path, data, undefined, options, { ...baseHeaders, ...headers });
+    }
+    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/CamScripterAPI.js

@@ -1,52 +1,61 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { packageInfoListSchema, storageSchema, } from './types/CamScripterAPI';
+import { ProxyClient } from './internal/ProxyClient';
+import { responseStringify } from './internal/utils';
+import { cameraTimeResponseSchema, nodeStateSchema, packageInfoListSchema, cameraStorageSchema, } from './types/CamScripterAPI';
 import { networkCameraListSchema } from './types/common';
-export class CamOverlayAPI {
+const BASE_PATH = '/local/camscripter';
+export class CamScripterAPI {
     client;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
+    }
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
     }
-    async checkCameraTime() {
-        return (await this.get('/local/camscripter/camera_time.cgi')).state;
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return cameraTimeResponseSchema.parse(res).state;
     }
-    async getStorageInfo() {
-        const data = await this.get(`/local/camscripter/package/get_storage.cgi`);
-        return storageSchema.parse(data);
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return networkCameraListSchema.parse(res.camera_list);
     }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camscripter/network_camera_list.cgi');
-        return networkCameraListSchema.parse(response.camera_list);
+    async getStorageInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
+        return cameraStorageSchema.parse(res);
     }
-    async getPackageList() {
-        const data = await this.get('/local/camscripter/package/list.cgi');
-        return packageInfoListSchema.parse(data);
+    async getPackageList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/list.cgi`, undefined, options);
+        return packageInfoListSchema.parse(res);
     }
-    async installPackages(formData, storage) {
-        await this.post(`/local/camscripter/package/install.cgi?storage=${storage}`, formData);
+    async installPackages(formData, storage, options) {
+        await this._post(`${BASE_PATH}/package/install.cgi`, formData, { storage: storage }, options);
     }
-    async uninstallPackage(packageId) {
-        await this.get(`/local/camscripter/package/remove.cgi?package_name=${packageId}`);
+    async uninstallPackage(packageId, options) {
+        await this._getJson(`${BASE_PATH}/package/remove.cgi`, { package_name: packageId }, options);
     }
-    async importSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData);
+    async importSettings(packageId, formData, options) {
+        await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+            action: 'IMPORT',
+            package_name: packageId,
+        }, options);
     }
-    async exportSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=EXPORT&package_name=${packageId}`, formData);
+    async exportSettings(packageId, formData, options) {
+        await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+            action: 'EXPORT',
+            package_name: packageId,
+        }, options);
     }
-    async getNodejsStatus() {
-        return (await this.get('/local/camscripter/diagnostics.cgi')).node_state;
+    async getNodejsStatus(options) {
+        const res = await this._getJson(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
+        return nodeStateSchema.parse(res);
     }
-    async installNodejs(storage) {
-        await this.get(`/local/camscripter/node_update.cgi?storage=${storage}`);
+    async installNodejs(storage, options) {
+        await this._getJson(`${BASE_PATH}/node_update.cgi`, { storage: storage }, options);
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async _getJson(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
@@ -54,8 +63,9 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async post(path, data, params) {
-        const res = await this.client.post(path, data, params);
+    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();
         }

package/esm/CamStreamerAPI.js

@@ -1,56 +1,74 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { streamAttributesSchema, streamListSchema, } from './types/CamStreamerAPI';
+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;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
+    constructor(client) {
+        this.client = client;
+    }
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        if (res.status !== 200) {
+            throw new WsAuthorizationError(res.message);
         }
-        else {
-            this.client = new DefaultClient(options);
+        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 UtcTimeFetchError(res.message);
         }
+        return z.number().parse(res.data);
     }
-    async getStreamList() {
-        const streamListRes = await this.get('/local/camstreamer/stream/list.cgi');
-        return streamListSchema.parse(streamListRes.data);
+    async getStreamList(options) {
+        const res = await this._getJson(`${BASE_PATH}/stream/list.cgi`, undefined, options);
+        const list = z.record(z.string(), cameraStreamSchema).parse(res.data);
+        const streamList = {};
+        for (const [key, data] of Object.entries(list)) {
+            const streamId = parseInt(key);
+            streamList[streamId] = parseCameraStreamResponse(data);
+        }
+        return streamList;
     }
-    async getStream(streamID) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
-        return streamAttributesSchema.parse(stream.data);
+    async getStream(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
+        const cameraData = cameraStreamSchema.parse(res.data);
+        return parseCameraStreamResponse(cameraData);
     }
-    async getStreamParameter(streamID, paramName) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
-        return stream.data[paramName];
+    async getStreamParameter(streamId, paramName, options) {
+        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
+        return z.string().parse(res.data[paramName]);
     }
-    async setStream(streamID, params) {
+    async setStream(streamId, params, options) {
         const { streamDelay, startTime, stopTime, ...rest } = params;
-        await this.get('/local/camstreamer/stream/set.cgi', {
-            stream_id: streamID,
+        await this._getJson(`${BASE_PATH}/stream/set.cgi`, {
+            stream_id: streamId,
             streamDelay: streamDelay ?? '',
-            startTime: startTime ?? 'null',
-            stopTime: stopTime ?? 'null',
+            startTime: startTime ?? null,
+            stopTime: stopTime ?? null,
             ...rest,
-        });
-    }
-    async setStreamParameter(streamID, paramName, value) {
-        await this.get(`/local/camstreamer/stream/set.cgi?stream_id=${streamID}&${paramName}=${value}`);
-    }
-    async isStreaming(streamID) {
-        const response = await this.get(`/local/camstreamer/get_streamstat.cgi?stream_id=${streamID}`);
-        return response.data.is_streaming === 1;
+        }, options);
     }
-    async deleteStream(streamID) {
-        await this.get('/local/camstreamer/stream/remove.cgi', { stream_id: streamID });
+    async setStreamParameter(streamId, paramName, value, options) {
+        await this._getJson(`${BASE_PATH}/stream/set.cgi`, { stream_id: streamId, [paramName]: value }, options);
     }
-    wsAutoratization() {
-        return this.get('/local/camstreamer/ws_authorization.cgi');
+    async isStreaming(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);
+        return res.data.is_streaming === 1;
     }
-    async getUtcTime() {
-        return await this.get('/local/camstreamer/get_utc_time.cgi');
+    async deleteStream(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/stream/remove.cgi`, { stream_id: streamId }, options);
+        return res.data.status === 200;
     }
-    async get(path, parameters) {
-        const res = await this.client.get(path, parameters);
+    async _getJson(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
@@ -59,3 +77,28 @@ export class CamStreamerAPI {
         }
     }
 }
+export const parseCameraStreamResponse = (cameraStreamData) => {
+    return {
+        enabled: parseInt(cameraStreamData.enabled),
+        active: parseInt(cameraStreamData.active),
+        audioSource: cameraStreamData.audioSource,
+        avSyncMsec: parseInt(cameraStreamData.avSyncMsec),
+        internalVapixParameters: cameraStreamData.internalVapixParameters,
+        userVapixParameters: cameraStreamData.userVapixParameters,
+        outputParameters: cameraStreamData.outputParameters,
+        outputType: cameraStreamData.outputType,
+        mediaServerUrl: cameraStreamData.mediaServerUrl,
+        inputType: cameraStreamData.inputType,
+        inputUrl: cameraStreamData.inputUrl,
+        forceStereo: parseInt(cameraStreamData.forceStereo),
+        streamDelay: isNaN(parseInt(cameraStreamData.streamDelay)) ? null : parseInt(cameraStreamData.streamDelay),
+        statusLed: parseInt(cameraStreamData.statusLed),
+        statusPort: cameraStreamData.statusPort,
+        callApi: parseInt(cameraStreamData.callApi),
+        trigger: cameraStreamData.trigger,
+        schedule: cameraStreamData.schedule,
+        prepareAhead: parseInt(cameraStreamData.prepareAhead),
+        startTime: isNaN(parseInt(cameraStreamData.startTime)) ? null : parseInt(cameraStreamData.startTime),
+        stopTime: isNaN(parseInt(cameraStreamData.stopTime)) ? null : parseInt(cameraStreamData.stopTime),
+    };
+};