camstreamerlib 4.0.0-beta.119 → 4.0.0-beta.120

package/esm/CamOverlayAPI.js

@@ -1,21 +1,13 @@
-import { paramToUrl } from './internal/utils';
-import { ParsingBlobError, ErrorWithResponse, ServiceNotFoundError, StorageDataFetchError } from './errors/errors';
+import { ErrorWithResponse, ServiceNotFoundError, StorageDataFetchError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
 import { z } from 'zod';
-import { ProxyClient } from './internal/ProxyClient';
 import { ImageType, serviceListSchema, servicesSchema, wsResponseSchema, getStorageDataListSchema, getFileListSchema, } from './types/CamOverlayAPI';
+import { BasicAPI } from './internal/BasicAPI';
 const BASE_PATH = '/local/camoverlay/api';
-export class CamOverlayAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
+export class CamOverlayAPI extends BasicAPI {
     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 checkAPIAvailable(options) {
         await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
     }
@@ -48,7 +40,7 @@ export class CamOverlayAPI {
         await this._postUrlEncoded(`${BASE_PATH}/upload_${fileType}.cgi`, {
             action: 'remove',
             ...fileParams,
-        }, options, undefined);
+        }, options);
     }
     async getFileStorage(fileType, options) {
         const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'get_storage' }, options);
@@ -99,15 +91,15 @@ export class CamOverlayAPI {
         return services;
     }
     async updateSingleService(service, options) {
-        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify(service), {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, service, {
             action: 'set',
             service_id: service.id,
-        }, options, undefined);
+        }, options);
     }
     async updateServices(services, options) {
-        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify({ services: services }), {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, { services: services }, {
             action: 'set',
-        }, options, undefined);
+        }, options);
     }
     updateCGText(serviceId, fields, options) {
         const params = {};
@@ -146,6 +138,9 @@ export class CamOverlayAPI {
         };
         return this.promiseCGUpdate(serviceId, 'update_image', params, contentType, imageData, options);
     }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
+    }
     async promiseCGUpdate(serviceId, action, params = {}, contentType, data, options) {
         const path = `${BASE_PATH}/customGraphics.cgi`;
         let headers = {};
@@ -168,51 +163,4 @@ export class CamOverlayAPI {
             throw new ErrorWithResponse(res);
         }
     }
-    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();
-        }
-        else {
-            throw new ErrorWithResponse(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();
-        }
-        else {
-            throw new ErrorWithResponse(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 ErrorWithResponse(res);
-        }
-    }
-    async parseBlobResponse(response) {
-        try {
-            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,17 +1,9 @@
-import { ErrorWithResponse } from './errors/errors';
-import { ProxyClient } from './internal/ProxyClient';
+import { BasicAPI } from './internal/BasicAPI';
 import { cameraTimeResponseSchema, nodeStateSchema, packageInfoListSchema, cameraStorageSchema, } from './types/CamScripterAPI';
 import { networkCameraListSchema } from './types/common';
 const BASE_PATH = '/local/camscripter';
-export class CamScripterAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
+export class CamScripterAPI extends BasicAPI {
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
     async checkAPIAvailable(options) {
         await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
     }
@@ -56,24 +48,7 @@ export class CamScripterAPI {
     async installNodejs(storage, options) {
         await this._getJson(`${BASE_PATH}/node_update.cgi`, { storage: storage }, options);
     }
-    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();
-        }
-        else {
-            throw new ErrorWithResponse(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();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
 }

package/esm/CamStreamerAPI.js

@@ -1,20 +1,12 @@
 import { z } from 'zod';
-import { ProxyClient } from './internal/ProxyClient';
 import { audioFileListSchema, storageListSchema, streamSchema, } from './types/CamStreamerAPI/CamStreamerAPI';
-import { ErrorWithResponse, UtcTimeFetchError, WsAuthorizationError, MigrationError, ParsingBlobError, } from './errors/errors';
+import { UtcTimeFetchError, WsAuthorizationError, MigrationError } from './errors/errors';
 import { oldStringStreamSchema, oldStringStreamSchemaWithId, } from './types/CamStreamerAPI/oldStreamSchema';
-import { paramToUrl } from './internal/utils';
+import { BasicAPI } from './internal/BasicAPI';
 const BASE_PATH = '/local/camstreamer';
-export class CamStreamerAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
+export class CamStreamerAPI extends BasicAPI {
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     static getWsEventsPath = () => `${BASE_PATH}/events`;
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
     async checkAPIAvailable(options) {
         await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
     }
@@ -77,7 +69,7 @@ export class CamStreamerAPI {
         return newStreamData;
     }
     async setStreamList(streamList, options) {
-        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify({ streamList }), {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, { streamList }, {
             action: 'set',
         }, options);
     }
@@ -91,7 +83,7 @@ export class CamStreamerAPI {
         throw new MigrationError([], [{ streamId, ...parseCameraStreamResponse(oldStream) }]);
     }
     async setStream(streamId, streamData, options) {
-        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify(streamData), {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, streamData, {
             action: 'set',
             stream_id: streamId,
         }, options);
@@ -117,7 +109,7 @@ export class CamStreamerAPI {
         }, options);
     }
     async removeFile(fileParams, options) {
-        await this._postUrlEncoded(`${BASE_PATH}/upload_audio.cgi`, { action: 'remove', ...fileParams }, options, undefined);
+        await this._postUrlEncoded(`${BASE_PATH}/upload_audio.cgi`, { action: 'remove', ...fileParams }, options);
     }
     async getFileStorage(options) {
         const res = await this._getJson(`${BASE_PATH}/upload_audio.cgi`, { action: 'get_storage' }, options);
@@ -126,69 +118,8 @@ export class CamStreamerAPI {
     async getFileFromCamera(path, options) {
         return await this._getBlob(`${BASE_PATH}/audio.cgi`, { path }, options);
     }
-    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();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
-    }
-    async _getText(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.text();
-        }
-        else {
-            throw new ErrorWithResponse(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 ErrorWithResponse(res);
-        }
-    }
-    async parseBlobResponse(response) {
-        try {
-            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 agent = this.getClient(options?.proxyParams);
-        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        return agent.post({
-            path,
-            data,
-            parameters,
-            timeout: options?.timeout,
-            headers: { ...baseHeaders, ...headers },
-        });
-    }
-    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();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
 }
 export const parseCameraStreamResponse = (cameraStreamData) => {

package/esm/CamSwitcherAPI.js

@@ -1,27 +1,23 @@
 import { z } from 'zod';
-import { AddNewClipError, JsonParseError, ParameterNotFoundError, ErrorWithResponse } from './errors/errors';
+import { AddNewClipError, JsonParseError, ParameterNotFoundError } from './errors/errors';
 import { parseBitrateOptionsToVapixParams, parseVapixParamsToBitrateOptions } from './internal/convertors';
 import { isClip, isNullish } from './internal/utils';
 import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, secondaryAudioSettingsSchema, globalAudioSettingsSchema, } from './types/CamSwitcherAPI';
 import { networkCameraListSchema, } from './types/common';
 import { VapixAPI } from './VapixAPI';
-import { ProxyClient } from './internal/ProxyClient';
+import { BasicAPI } from './internal/BasicAPI';
 const BASE_PATH = '/local/camswitcher/api';
-export class CamSwitcherAPI {
-    client;
+export class CamSwitcherAPI extends BasicAPI {
     CustomFormData;
     vapixAgent;
     constructor(client, CustomFormData = FormData) {
-        this.client = client;
+        super(client);
         this.CustomFormData = CustomFormData;
         this.vapixAgent = new VapixAPI(client);
     }
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     static getWsEventsPath = () => `/local/camswitcher/events`;
     static getClipPreviewPath = (clipId, storage) => `${BASE_PATH}/clip_preview.cgi?clip_name=${clipId}&storage=${storage}`;
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
     async checkAPIAvailable(options) {
         await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
     }
@@ -261,25 +257,8 @@ export class CamSwitcherAPI {
         const res = await this.vapixAgent.getParameter([paramName], options);
         return z.string().parse(res[paramName] ?? '');
     }
-    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();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
-    }
-    async _post(path, data, parameters, options, headers) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ path, data, parameters, timeout: options?.timeout, headers });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
     setParamFromCameraJSON(paramName, data, options) {
         const params = {};

package/esm/PlaneTrackerAPI.js

@@ -1,22 +1,17 @@
 import { z } from 'zod';
-import { paramToUrl } from './internal/utils';
 import { blackListSchema, cameraSettingsSchema, flightInfoSchema, getIcaoSchema, mapInfoSchema, priorityListSchema, serverSettingsSchema, trackingModeSchema, typePriorityListSchema, whiteListSchema, wsAliasResponseSchema, zonesSchema, } from './types/PlaneTrackerAPI';
-import { CannotSetCoordsInAutoModeError, ImportSettingsError, InvalidAltitudeError, InvalidLatLngError, ParsingBlobError, ResetCalibrationError, ServerError, BadRequestError, ErrorWithResponse, } from './errors/errors';
-import { ProxyClient } from './internal/ProxyClient';
+import { CannotSetCoordsInAutoModeError, ImportSettingsError, InvalidAltitudeError, InvalidLatLngError, ResetCalibrationError, ServerError, BadRequestError, } from './errors/errors';
 import { cameraListSchema } from './types/GenetecAgent';
+import { BasicAPI } from './internal/BasicAPI';
 const BASE_PATH = '/local/planetracker';
-export class PlaneTrackerAPI {
-    client;
+export class PlaneTrackerAPI extends BasicAPI {
     apiUser;
     constructor(client, apiUser) {
-        this.client = client;
+        super(client);
         this.apiUser = apiUser;
     }
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     static getWsEventsPath = () => `${BASE_PATH}/package/ws`;
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
     async checkAPIAvailable(options) {
         await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
     }
@@ -182,6 +177,9 @@ export class PlaneTrackerAPI {
             }
         }
     }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
+    }
     async checkGenetecConnection(params, options) {
         return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, params, options);
     }
@@ -189,65 +187,4 @@ export class PlaneTrackerAPI {
         const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, params, options);
         return cameraListSchema.parse(await res.json());
     }
-    async _getJson(path, parameters, options, headers) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ path, parameters, timeout: options?.timeout, headers });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(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 ErrorWithResponse(res);
-        }
-    }
-    async parseBlobResponse(response) {
-        try {
-            return (await response.blob());
-        }
-        catch (err) {
-            throw new ParsingBlobError(err);
-        }
-    }
-    async _postJsonEncoded(path, data, parameters, options) {
-        const agent = this.getClient(options?.proxyParams);
-        const jsonData = JSON.stringify(data);
-        const res = await agent.post({
-            path,
-            data: jsonData,
-            parameters,
-            headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-            timeout: options?.timeout,
-        });
-        if (res.ok) {
-            return res;
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
-    }
-    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 ErrorWithResponse(res);
-        }
-    }
 }

package/esm/internal/BasicAPI.js

@@ -0,0 +1,93 @@
+import { ErrorWithResponse, ParsingBlobError } from '../errors/errors';
+import { ProxyClient } from './ProxyClient';
+import { paramToUrl } from './utils';
+export class BasicAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    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();
+        }
+        else {
+            throw new ErrorWithResponse(res);
+        }
+    }
+    async _getText(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.text();
+        }
+        else {
+            throw new ErrorWithResponse(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 ErrorWithResponse(res);
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new ParsingBlobError(err);
+        }
+    }
+    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();
+        }
+        else {
+            throw new ErrorWithResponse(res);
+        }
+    }
+    async _postJsonEncoded(path, data, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const jsonData = JSON.stringify(data);
+        const res = await agent.post({
+            path,
+            data: jsonData,
+            parameters,
+            headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
+            timeout: options?.timeout,
+        });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new ErrorWithResponse(res);
+        }
+    }
+    async _postUrlEncoded(path, data, options) {
+        const encodedData = paramToUrl(data);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data: encodedData,
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            timeout: options?.timeout,
+        });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new ErrorWithResponse(res);
+        }
+    }
+}

package/esm/types/CamStreamerAPI/streamCommonTypes.js

@@ -8,12 +8,13 @@ export const streamCommonSchema = z.object({
     trigger: z.discriminatedUnion('type', [
         z.object({
             type: z.literal('manual'),
-            ioPort: z.number().nullable(),
+            port: z.number().optional(),
         }),
         z.object({
             type: z.literal('onetime'),
             startTime: z.number(),
             stopTime: z.number(),
+            prepareAheadS: z.number().int().optional(),
         }),
         z.object({
             type: z.literal('recurrent'),
@@ -28,22 +29,15 @@ export const streamCommonSchema = z.object({
                 }),
                 isActive: z.boolean(),
             })),
+            prepareAheadS: z.number().int().optional(),
         }),
     ]),
     video: z.object({
-        output: z.discriminatedUnion('callApi', [
-            z.object({
-                type: z.union([z.literal('video'), z.literal('images')]),
-                callApi: z.literal(false),
-                url: z.string(),
-            }),
-            z.object({
-                type: z.literal('video'),
-                callApi: z.literal(true),
-                prepareAheadS: z.number(),
-            }),
-        ]),
-        outputParameters: z.string(),
+        output: z.object({
+            type: z.union([z.literal('video'), z.literal('images')]),
+            url: z.string().nullable(),
+            parameters: z.string(),
+        }),
         input: z.discriminatedUnion('type', [
             z.object({
                 type: z.literal('RTSP_URL'),
@@ -54,20 +48,17 @@ export const streamCommonSchema = z.object({
             }),
             z.object({
                 type: z.literal('CRS'),
+                streamingProtocol: z.union([z.literal('RTMP'), z.literal('RTMPS'), z.literal('HLS_PUSH')]),
+                internalVapixParameters: z.string(),
+                userVapixParameters: z.string(),
             }),
         ]),
-        streamingProtocol: z.union([z.literal('RTMP'), z.literal('RTMPS'), z.literal('HLS_PUSH')]),
-        internalVapixParameters: z.string(),
-        userVapixParameters: z.string(),
-        streamDelay: z
-            .object({
-            value: z.number().int(),
-            unit: z.union([z.literal('seconds'), z.literal('minutes'), z.literal('hours')]),
-        })
-            .optional(),
+        delayS: z.number().int().nonnegative().optional(),
     }),
-    audio: z
-        .discriminatedUnion('source', [
+    audio: z.discriminatedUnion('source', [
+        z.object({
+            source: z.literal('none'),
+        }),
         z.object({
             source: z.literal('microphone'),
             audioChannelNbr: z.union([z.literal(1), z.literal(2)]),
@@ -75,22 +66,21 @@ export const streamCommonSchema = z.object({
         }),
         z.object({
             source: z.literal('file'),
-            fileName: z.string(),
-            filePath: z.string(),
+            name: z.string(),
+            path: z.string(),
             forceStereo: z.boolean(),
         }),
         z.object({
             source: z.literal('url'),
-            fileName: z.string(),
-            fileUrl: z.string(),
+            name: z.string(),
+            url: z.string(),
             avSyncMsec: z.number().int().nonnegative(),
             forceStereo: z.boolean(),
         }),
-    ])
-        .nullable(),
+    ]),
     status: z.object({
         led: z.boolean(),
-        port: z.number().nullable(),
+        port: z.number().optional(),
     }),
 });
 export const internalVapixParametersSchema = bitrateVapixParamsSchema.extend({

package/package.json

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