camstreamerlib 4.0.0-beta.36 → 4.0.0-beta.38

package/cjs/CamOverlayAPI.js

@@ -20,68 +20,51 @@ class CamOverlayAPI {
         return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
     }
     async checkCameraTime(options) {
-        const response = await this._get({ path: `${BASE_PATH}/camera_time.cgi` }, options);
-        return zod_1.z.boolean().parse(response.state);
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return zod_1.z.boolean().parse(res.state);
     }
     async getNetworkCameraList(options) {
-        const response = await this._get({ path: `${BASE_PATH}/network_camera_list.cgi` }, options);
-        return common_1.networkCameraListSchema.parse(response.camera_list);
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return common_1.networkCameraListSchema.parse(res.camera_list);
     }
     async wsAuthorization(options) {
-        const response = await this._get({ path: `${BASE_PATH}/ws_authorization.cgi` }, options);
-        return CamOverlayAPI_1.WSResponseSchema.parse(response).message;
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        return CamOverlayAPI_1.wsResponseSchema.parse(res).message;
     }
     async getMjpegStreamImage(mjpegUrl, options) {
-        return await this._getBlob({
-            path: `${BASE_PATH}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`,
-        }, options);
+        return await this._getBlob(`${BASE_PATH}/fetch_mjpeg_image.cgi`, { mjpeg_url: decodeURIComponent(mjpegUrl) }, options);
     }
     async listFiles(fileType, options) {
-        const files = await this._get({
-            path: `${BASE_PATH}/upload_${fileType}.cgi`,
-            parameters: {
-                action: 'list',
-            },
-        }, options);
-        return CamOverlayAPI_1.fileListSchema.parse(files.list);
+        const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'list' }, options);
+        return CamOverlayAPI_1.fileListSchema.parse(res.list);
     }
     async uploadFile(fileType, formData, storage, options) {
-        await this._post({
-            path: `${BASE_PATH}/upload_${fileType}.cgi`,
-            data: formData,
-            parameters: {
-                action: 'upload',
-                storage: storage,
-            },
+        await this._post(`${BASE_PATH}/upload_${fileType}.cgi`, formData, {
+            action: 'upload',
+            storage: storage,
         }, options);
     }
     async removeFile(fileType, fileParams, options) {
-        const path = `${BASE_PATH}/upload_${fileType}.cgi`;
-        await this._postUrlEncoded(path, {
+        await this._postUrlEncoded(`${BASE_PATH}/upload_${fileType}.cgi`, {
             action: 'remove',
             ...fileParams,
-        }, undefined, options);
+        }, options, undefined);
     }
     async getFileStorage(fileType, options) {
-        const data = await this._get({
-            path: `${BASE_PATH}/upload_${fileType}.cgi`,
-            parameters: {
-                action: 'get_storage',
-            },
-        }, options);
-        if (data.code !== 200) {
+        const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'get_storage' }, options);
+        if (res.code !== 200) {
             throw new Error('Error occured while fetching file storage data');
         }
-        return CamOverlayAPI_1.storageDataListSchema.parse(data.list);
+        return CamOverlayAPI_1.storageDataListSchema.parse(res.list);
     }
     async getFilePreviewFromCamera(path, options) {
-        return await this._getBlob({ path: CamOverlayAPI.getFilePreviewPath(path) }, options);
+        return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path), undefined, options);
     }
     async updateInfoticker(serviceId, text, options) {
-        await this._get({ path: `${BASE_PATH}/infoticker.cgi?service_id=${serviceId}&text=${text}` }, options);
+        await this._getJson(`${BASE_PATH}/infoticker.cgi`, { service_id: serviceId, text: text }, options);
     }
     async setEnabled(serviceId, enabled, options) {
-        await this._post({ path: `${BASE_PATH}/enabled.cgi?id_${serviceId}=${enabled ? 1 : 0}`, data: '' }, options);
+        await this._post(`${BASE_PATH}/enabled.cgi`, '', { [`id_${serviceId}`]: enabled ? 1 : 0 }, options);
     }
     async isEnabled(serviceId, options) {
         const agent = this.getClient(options?.proxyParams);
@@ -99,44 +82,34 @@ class CamOverlayAPI {
             throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async getSingleWidget(serviceId, options) {
-        const data = await this._get({
-            path: `${BASE_PATH}/services.cgi`,
-            parameters: {
-                action: 'get',
-                service_id: serviceId.toString(),
-            },
-        }, options);
-        return CamOverlayAPI_1.widgetsSchema.parse(data);
-    }
-    async getWidgets(options) {
-        const widgetList = await this._get({
-            path: `${BASE_PATH}/services.cgi`,
-            parameters: {
-                action: 'get',
-            },
+    async getSingleService(serviceId, options) {
+        const res = await this._getJson(`${BASE_PATH}/services.cgi`, {
+            action: 'get',
+            service_id: serviceId,
         }, options);
-        const widgets = widgetList.services;
-        widgets.forEach((widget) => {
-            const parsedWidget = CamOverlayAPI_1.widgetsSchema.safeParse(widget);
-            if (!parsedWidget.success) {
-                console.warn(`[SERVICE SCHEMA MISMATCH]: Service ${widget.name} (${widget.id}) does not match the current schema, or is a hidden service.`);
+        return CamOverlayAPI_1.servicesSchema.parse(res);
+    }
+    async getServices(options) {
+        const res = await this._getJson(`${BASE_PATH}/services.cgi`, { action: 'get' }, options);
+        const services = CamOverlayAPI_1.serviceListSchema.parse(res).services;
+        services.forEach((service) => {
+            const parsedService = CamOverlayAPI_1.servicesSchema.safeParse(service);
+            if (!parsedService.success) {
+                console.warn(`[SERVICE SCHEMA MISMATCH]: Service ${service.name} (${service.id}) does not match the current schema, or is a hidden service.`);
             }
         });
-        return widgets;
+        return services;
     }
-    async updateSingleWidget(widget, options) {
-        const path = `${BASE_PATH}/services.cgi`;
-        await this._postJsonEncoded(path, JSON.stringify(widget), {
+    async updateSingleService(service, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify(service), {
             action: 'set',
-            service_id: widget.id.toString(),
-        }, undefined, options);
+            service_id: service.id,
+        }, options, undefined);
     }
-    async updateWidgets(widgets, options) {
-        const path = `${BASE_PATH}/services.cgi`;
-        await this._postJsonEncoded(path, JSON.stringify({ services: widgets }), {
+    async updateServices(services, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify({ services: services }), {
             action: 'set',
-        }, undefined, options);
+        }, options, undefined);
     }
     updateCGText(serviceId, fields, options) {
         const params = {};
@@ -197,9 +170,9 @@ class CamOverlayAPI {
             throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async _get(params, options) {
+    async _getJson(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ ...params, timeout: options?.timeout });
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
@@ -207,9 +180,9 @@ class CamOverlayAPI {
             throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async _post(params, options) {
+    async _post(path, data, parameters, options, headers) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ ...params, timeout: options?.timeout });
+        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
@@ -217,9 +190,9 @@ class CamOverlayAPI {
             throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async _getBlob(params, options) {
+    async _getBlob(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ ...params, timeout: options?.timeout });
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await this.parseBlobResponse(res);
         }
@@ -235,14 +208,14 @@ class CamOverlayAPI {
             throw new errors_1.ParsingBlobError(err);
         }
     }
-    async _postUrlEncoded(path, params, headers, options) {
-        const data = (0, utils_1.paramToUrl)(params);
+    async _postUrlEncoded(path, parameters, options, headers) {
+        const data = (0, utils_1.paramToUrl)(parameters);
         const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
-        return this._post({ path, data, headers: { ...baseHeaders, ...headers } }, options);
+        return this._post(path, data, undefined, options, { ...baseHeaders, ...headers });
     }
-    async _postJsonEncoded(path, data, parameters, headers, options) {
+    async _postJsonEncoded(path, data, parameters, options, headers) {
         const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        return this._post({ path, data, parameters, headers: { ...baseHeaders, ...headers } }, options);
+        return this._post(path, data, parameters, options, { ...baseHeaders, ...headers });
     }
 }
 exports.CamOverlayAPI = CamOverlayAPI;

package/cjs/CamScripterAPI.js

@@ -11,51 +11,57 @@ class CamScripterAPI {
     constructor(client) {
         this.client = client;
     }
-    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     getClient(proxyParams) {
         return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
     }
     async checkCameraTime(options) {
-        const data = await this.get(`${BASE_PATH}/camera_time.cgi`, undefined, options);
-        return CamScripterAPI_1.cameraTimeResponseSchema.parse(data).state;
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return CamScripterAPI_1.cameraTimeResponseSchema.parse(res).state;
     }
     async getNetworkCameraList(options) {
-        const data = await this.get(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
-        return common_1.networkCameraListSchema.parse(data.camera_list);
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return common_1.networkCameraListSchema.parse(res.camera_list);
     }
     async getStorageInfo(options) {
-        const data = await this.get(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
-        return CamScripterAPI_1.storageSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
+        return CamScripterAPI_1.storageSchema.parse(res);
     }
     async getPackageList(options) {
-        const data = await this.get(`${BASE_PATH}/package/list.cgi`, undefined, options);
-        return CamScripterAPI_1.packageInfoListSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/package/list.cgi`, undefined, options);
+        return CamScripterAPI_1.packageInfoListSchema.parse(res);
     }
     async installPackages(formData, storage, options) {
-        const data = await this.post(`${BASE_PATH}/package/install.cgi?storage=${storage}`, formData, undefined, options);
-        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
+        const res = await this._post(`${BASE_PATH}/package/install.cgi`, formData, { storage: storage }, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(res);
     }
     async uninstallPackage(packageId, options) {
-        const data = await this.get(`${BASE_PATH}/package/remove.cgi?package_name=${packageId}`, undefined, options);
-        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/package/remove.cgi`, { package_name: packageId }, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(res);
     }
     async importSettings(packageId, formData, options) {
-        const data = await this.post(`${BASE_PATH}/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData, undefined, options);
-        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
+        const res = await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+            action: 'IMPORT',
+            package_name: packageId,
+        }, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(res);
     }
     async exportSettings(packageId, formData, options) {
-        const data = await this.post(`${BASE_PATH}/package/data.cgi?action=EXPORT&package_name=${packageId}`, formData, undefined, options);
-        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
+        const res = await this._post(`${BASE_PATH}/package/data.cgi`, formData, {
+            action: 'EXPORT',
+            package_name: packageId,
+        }, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(res);
     }
     async getNodejsStatus(options) {
-        const data = await this.get(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
-        return CamScripterAPI_1.nodeStateSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
+        return CamScripterAPI_1.nodeStateSchema.parse(res);
     }
     async installNodejs(storage, options) {
-        const data = await this.get(`${BASE_PATH}/node_update.cgi?storage=${storage}`, undefined, options);
-        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/node_update.cgi`, { storage: storage }, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(res);
     }
-    async get(path, parameters, 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) {
@@ -65,9 +71,9 @@ class CamScripterAPI {
             throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async post(path, data, parameters, options) {
+    async _post(path, data, parameters, options, headers) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ path, data, parameters, timeout: options?.timeout });
+        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }

package/cjs/CamStreamerAPI.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCameraStreamResponse = exports.CamStreamerAPI = void 0;
-const zod_1 = __importDefault(require("zod"));
+const zod_1 = require("zod");
 const ProxyClient_1 = require("./internal/ProxyClient");
 const utils_1 = require("./internal/utils");
 const CamStreamerAPI_1 = require("./types/CamStreamerAPI");
@@ -17,28 +14,42 @@ class CamStreamerAPI {
     getClient(proxyParams) {
         return proxyParams ? new ProxyClient_1.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 Error(`Server error on ws authorization: ${res.message}`);
+        }
+        return zod_1.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 Error(`Server error on get UTC time: ${res.message}`);
+        }
+        return zod_1.z.number().parse(res.data);
+    }
     async getStreamList(options) {
-        const streamListRes = await this.get(`${BASE_PATH}/stream/list.cgi`, undefined, options);
-        const list = zod_1.default.record(zod_1.default.string(), CamStreamerAPI_1.cameraStreamSchema).parse(streamListRes.data);
-        const res = {};
+        const res = await this._getJson(`${BASE_PATH}/stream/list.cgi`, undefined, options);
+        const list = zod_1.z.record(zod_1.z.string(), CamStreamerAPI_1.cameraStreamSchema).parse(res.data);
+        const streamList = {};
         for (const [key, data] of Object.entries(list)) {
             const streamId = parseInt(key);
-            res[streamId] = (0, exports.parseCameraStreamResponse)(data);
+            streamList[streamId] = (0, exports.parseCameraStreamResponse)(data);
         }
-        return res;
+        return streamList;
     }
     async getStream(streamId, options) {
-        const stream = await this.get(`${BASE_PATH}/stream/get.cgi?stream_id=${streamId}`, undefined, options);
-        const cameraData = CamStreamerAPI_1.cameraStreamSchema.parse(stream.data);
+        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
+        const cameraData = CamStreamerAPI_1.cameraStreamSchema.parse(res.data);
         return (0, exports.parseCameraStreamResponse)(cameraData);
     }
     async getStreamParameter(streamId, paramName, options) {
-        const stream = await this.get(`${BASE_PATH}/stream/get.cgi?stream_id=${streamId}`, undefined, options);
-        return stream.data[paramName];
+        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
+        return zod_1.z.string().parse(res.data[paramName]);
     }
     async setStream(streamId, params, options) {
         const { streamDelay, startTime, stopTime, ...rest } = params;
-        return await this.get(`${BASE_PATH}/stream/set.cgi`, {
+        return await this._getJson(`${BASE_PATH}/stream/set.cgi`, {
             stream_id: streamId,
             streamDelay: streamDelay ?? '',
             startTime: startTime ?? null,
@@ -47,31 +58,17 @@ class CamStreamerAPI {
         }, options);
     }
     async setStreamParameter(streamId, paramName, value, options) {
-        return await this.get(`${BASE_PATH}/stream/set.cgi?stream_id=${streamId}&${paramName}=${value}`, undefined, options);
+        return await this._getJson(`${BASE_PATH}/stream/set.cgi`, { stream_id: streamId, [paramName]: value }, options);
     }
     async isStreaming(streamId, options) {
-        const response = await this.get(`${BASE_PATH}/get_streamstat.cgi?stream_id=${streamId}`, undefined, options);
-        return response.data.is_streaming === 1;
+        const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);
+        return res.data.is_streaming === 1;
     }
     async deleteStream(streamId, options) {
-        const res = await this.get(`${BASE_PATH}/stream/remove.cgi`, { stream_id: streamId }, options);
+        const res = await this._getJson(`${BASE_PATH}/stream/remove.cgi`, { stream_id: streamId }, options);
         return res.data.status === 200;
     }
-    async getWsAuthorization(options) {
-        const res = await this.get(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
-        if (res.status !== 200) {
-            throw new Error(`Server error on ws authorization: ${res.message}`);
-        }
-        return res.data;
-    }
-    async getUtcTime(options) {
-        const res = await this.get(`${BASE_PATH}/get_utc_time.cgi`, undefined, options);
-        if (res.status !== 200) {
-            throw new Error(`Server error on get UTC time: ${res.message}`);
-        }
-        return res.data;
-    }
-    async get(path, parameters, 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) {

package/cjs/CamSwitcherAPI.js

@@ -20,9 +20,9 @@ class CamSwitcherAPI {
         this.CustomFormData = CustomFormData;
         this.vapixAgent = new VapixAPI_1.VapixAPI(client);
     }
-    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
-    static getWsEventsUrlPath = () => `/local/camswitcher/events`;
-    static getClipPreviewUrlPath = (id, storage) => `${BASE_PATH}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getWsEventsPath = () => `/local/camswitcher/events`;
+    static getClipPreviewPath = (id, storage) => `${BASE_PATH}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
     getClient(proxyParams) {
         return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
     }
@@ -38,98 +38,105 @@ class CamSwitcherAPI {
         });
     }
     async checkCameraTime(options) {
-        const data = await this.get(`${BASE_PATH}/camera_time.cgi`, undefined, options);
-        return zod_1.z.boolean().parse(data);
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return zod_1.z.boolean().parse(res.data);
     }
     async getNetworkCameraList(options) {
-        const data = await this.get(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
-        return common_1.networkCameraListSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return common_1.networkCameraListSchema.parse(res.data);
     }
     async getMaxFps(source, options) {
-        const data = await this.get(`${BASE_PATH}/get_max_framerate.cgi`, {
-            video_source: source.toString(),
+        const res = await this._getJson(`${BASE_PATH}/get_max_framerate.cgi`, {
+            video_source: source,
         }, options);
-        return zod_1.z.number().parse(data);
+        return zod_1.z.number().parse(res.data);
     }
     async getStorageInfo(options) {
-        const data = await this.get(`${BASE_PATH}/get_storage.cgi`, undefined, options);
-        return CamSwitcherAPI_1.storageInfoListSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/get_storage.cgi`, undefined, options);
+        return CamSwitcherAPI_1.storageInfoListSchema.parse(res.data);
     }
     async wsAuthorization(options) {
-        const data = await this.get(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
-        return zod_1.z.string().parse(data);
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        return zod_1.z.string().parse(res.data);
     }
     async getOutputInfo(options) {
-        const data = await this.get(`${BASE_PATH}/output_info.cgi`, undefined, options);
-        return CamSwitcherAPI_1.outputInfoSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/output_info.cgi`, undefined, options);
+        return CamSwitcherAPI_1.outputInfoSchema.parse(res.data);
     }
     async getAudioPushInfo(options) {
-        const data = await this.get(`${BASE_PATH}/audio_push_info.cgi`, undefined, options);
-        return CamSwitcherAPI_1.audioPushInfoSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/audio_push_info.cgi`, undefined, options);
+        return CamSwitcherAPI_1.audioPushInfoSchema.parse(res.data);
     }
     async getStreamSaveList(options) {
-        const data = await this.get(`${BASE_PATH}/streams.cgi`, { action: 'get' }, options);
-        return CamSwitcherAPI_1.streamSaveLoadSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/streams.cgi`, { action: 'get' }, options);
+        return CamSwitcherAPI_1.streamSaveLoadSchema.parse(res.data);
     }
     async getClipSaveList(options) {
-        const data = await this.get(`${BASE_PATH}/clips.cgi`, { action: 'get' }, options);
-        return CamSwitcherAPI_1.clipSaveLoadSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/clips.cgi`, { action: 'get' }, options);
+        return CamSwitcherAPI_1.clipSaveLoadSchema.parse(res.data);
     }
     async getPlaylistSaveList(options) {
-        const data = await this.get(`${BASE_PATH}/playlists.cgi`, { action: 'get' }, options);
-        return CamSwitcherAPI_1.playlistSaveLoadSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/playlists.cgi`, { action: 'get' }, options);
+        return CamSwitcherAPI_1.playlistSaveLoadSchema.parse(res.data);
     }
     async getTrackerSaveList(options) {
-        const data = await this.get(`${BASE_PATH}/trackers.cgi`, { action: 'get' }, options);
-        return CamSwitcherAPI_1.trackerSaveLoadSchema.parse(data);
+        const res = await this._getJson(`${BASE_PATH}/trackers.cgi`, { action: 'get' }, options);
+        return CamSwitcherAPI_1.trackerSaveLoadSchema.parse(res.data);
     }
     async setStreamSaveList(data, options) {
-        return await this.set(`${BASE_PATH}/streams.cgi`, data, { action: 'set' }, options);
+        return await this._post(`${BASE_PATH}/streams.cgi`, data, { action: 'set' }, options);
     }
     async setClipSaveList(data, options) {
-        return await this.set(`${BASE_PATH}/clips.cgi`, data, { action: 'set' }, options);
+        return await this._post(`${BASE_PATH}/clips.cgi`, data, { action: 'set' }, options);
     }
     async setPlaylistSaveList(data, options) {
-        return await this.set(`${BASE_PATH}/playlists.cgi`, data, { action: 'set' }, options);
+        return await this._post(`${BASE_PATH}/playlists.cgi`, data, { action: 'set' }, options);
     }
     async setTrackerSaveList(data, options) {
-        return await this.set(`${BASE_PATH}/trackers.cgi`, data, { action: 'set' }, options);
+        return await this._post(`${BASE_PATH}/trackers.cgi`, data, { action: 'set' }, options);
     }
     async playlistSwitch(playlistName, options) {
-        await this.get(`${BASE_PATH}/playlist_switch.cgi`, { playlist_name: playlistName }, options);
+        await this._getJson(`${BASE_PATH}/playlist_switch.cgi`, { playlist_name: playlistName }, options);
     }
     async playlistQueuePush(playlistName, options) {
-        await this.get(`${BASE_PATH}/playlist_queue_push.cgi`, { playlist_name: playlistName }, options);
+        await this._getJson(`${BASE_PATH}/playlist_queue_push.cgi`, { playlist_name: playlistName }, options);
     }
     async playlistQueueClear(options) {
-        await this.get(`${BASE_PATH}/playlist_queue_clear.cgi`, undefined, options);
+        await this._getJson(`${BASE_PATH}/playlist_queue_clear.cgi`, undefined, options);
     }
     async playlistQueueList(options) {
-        const data = await this.get(`${BASE_PATH}/playlist_queue_list.cgi`, undefined, options);
-        return CamSwitcherAPI_1.playlistQueueSchema.parse(data).playlistQueueList;
+        const res = await this._getJson(`${BASE_PATH}/playlist_queue_list.cgi`, undefined, options);
+        return CamSwitcherAPI_1.playlistQueueSchema.parse(res.data).playlistQueueList;
     }
     async playlistQueuePlayNext(options) {
-        await this.get(`${BASE_PATH}/playlist_queue_play_next.cgi`, undefined, options);
+        await this._getJson(`${BASE_PATH}/playlist_queue_play_next.cgi`, undefined, options);
     }
     async addNewClip(file, clipType, storage, clipId, fileName, options) {
-        const path = `${BASE_PATH}/clip_upload.cgi?storage=${storage}`;
+        const path = `${BASE_PATH}/clip_upload.cgi`;
         const formData = new this.CustomFormData();
         formData.append('clip_name', clipId);
         formData.append('clip_type', clipType);
         formData.append('file', file, fileName);
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ path, data: formData, timeout: options?.timeout });
+        const res = await agent.post({
+            path,
+            data: formData,
+            parameters: {
+                storage: storage,
+            },
+            timeout: options?.timeout,
+        });
         const output = (await res.json());
         if (output.status !== 200) {
             throw new errors_1.AddNewClipError(output.message);
         }
     }
     removeClip(clipId, storage, options) {
-        return this.get(`${BASE_PATH}/clip_remove.cgi`, { clip_name: clipId, storage }, options);
+        return this._getJson(`${BASE_PATH}/clip_remove.cgi`, { clip_name: clipId, storage }, options);
     }
     async getClipList(options) {
-        const data = await this.get(`${BASE_PATH}/clip_list.cgi`, undefined, options);
-        return CamSwitcherAPI_1.clipListSchema.parse(data).clip_list;
+        const res = await this._getJson(`${BASE_PATH}/clip_list.cgi`, undefined, options);
+        return CamSwitcherAPI_1.clipListSchema.parse(res.data).clip_list;
     }
     setCamSwitchOptions(data, cameraFWVersion, options) {
         const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
@@ -230,7 +237,7 @@ class CamSwitcherAPI {
             settings.source = res.clip_name;
             settings.storage = res.storage;
         }
-        return settings;
+        return CamSwitcherAPI_1.globalAudioSettingsSchema.parse(settings);
     }
     async getSecondaryAudioSettings(options) {
         const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SECONDARY_AUDIO, options);
@@ -242,30 +249,28 @@ class CamSwitcherAPI {
             secondaryAudioLevel: res.secondary_audio_level ?? 1,
             masterAudioLevel: res.master_audio_level ?? 1,
         };
-        return settings;
+        return CamSwitcherAPI_1.secondaryAudioSettingsSchema.parse(settings);
     }
     async getPermanentRtspUrlToken(options) {
         const paramName = CSW_PARAM_NAMES.RTSP_TOKEN;
         const res = await this.vapixAgent.getParameter([paramName], options);
-        return res[paramName] ?? '';
+        return zod_1.z.string().parse(res[paramName] ?? '');
     }
-    async get(path, parameters, 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) {
-            const d = await res.json();
-            return d.data;
+            return await res.json();
         }
         else {
             throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async set(path, data, parameters, options) {
+    async _post(path, data, parameters, options, headers) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ path, data: JSON.stringify(data), parameters, timeout: options?.timeout });
+        const res = await agent.post({ path, data, parameters, timeout: options?.timeout, headers });
         if (res.ok) {
-            const parsed = await res.json();
-            return parsed.message === 'OK';
+            return await res.json();
         }
         else {
             throw new Error(await (0, utils_1.responseStringify)(res));
@@ -306,7 +311,7 @@ const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, c
     if (!(0, versionCompare_1.isFirmwareVersionAtLeast)(firmWareVersion, constants_1.FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
         return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
     }
-    if (bitrateMode === null) {
+    if (bitrateMode === undefined) {
         return '';
     }
     const data = {