camstreamerlib 4.0.0-beta.13 → 4.0.0-beta.130

package/esm/CamStreamerAPI.js

@@ -1,55 +1,153 @@
-import { responseStringify } from './internal/utils';
-import { streamAttributesSchema, streamListSchema } from './types/CamStreamerAPI';
-export class CamStreamerAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async getStreamList() {
-        const streamListRes = await this.get('/local/camstreamer/stream/list.cgi');
-        return streamListSchema.parse(streamListRes.data);
-    }
-    async getStream(streamID) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
-        return streamAttributesSchema.parse(stream.data);
-    }
-    async getStreamParameter(streamID, paramName) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
-        return stream.data[paramName];
-    }
-    async setStream(streamID, params) {
-        const { streamDelay, startTime, stopTime, ...rest } = params;
-        await this.get('/local/camstreamer/stream/set.cgi', {
-            stream_id: streamID,
-            streamDelay: streamDelay ?? '',
-            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;
-    }
-    async deleteStream(streamID) {
-        await this.get('/local/camstreamer/stream/remove.cgi', { stream_id: streamID });
-    }
-    wsAutoratization() {
-        return this.get('/local/camstreamer/ws_authorization.cgi');
-    }
-    async getUtcTime() {
-        return await this.get('/local/camstreamer/get_utc_time.cgi');
-    }
-    async get(path, parameters) {
-        const res = await this.client.get(path, parameters);
-        if (res.ok) {
-            return await res.json();
+import { z } from 'zod';
+import { audioFileListSchema, srtStreamStatisticsSchema, storageListSchema, streamSchema, streamStatsSchema, } from './types/CamStreamerAPI/CamStreamerAPI';
+import { UtcTimeFetchError, WsAuthorizationError, MigrationError } from './errors/errors';
+import { oldStringStreamSchema, oldStringStreamSchemaWithId, } from './types/CamStreamerAPI/oldStreamSchema';
+import { BasicAPI } from './internal/BasicAPI';
+const BASE_PATH = '/local/camstreamer';
+export class CamStreamerAPI extends BasicAPI {
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getWsEventsPath = () => `${BASE_PATH}/events`;
+    async checkAPIAvailable(options) {
+        await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
+    }
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        if (res.status !== 200) {
+            throw new WsAuthorizationError(res.message);
+        }
+        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 getMaxFps(source = 0, options) {
+        return await this._getJson(`${BASE_PATH}/get_max_framerate.cgi`, { video_source: source.toString() }, options);
+    }
+    async isCSPassValid(pass, options) {
+        const res = await this._getJson(`${BASE_PATH}/check_pass.cgi`, { pass }, options);
+        return res.data === '1';
+    }
+    async getCamStreamerAppLog(options) {
+        return await this._getText(`${BASE_PATH}/view_log.cgi`, undefined, options);
+    }
+    async getStreamList(options) {
+        const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get' }, options);
+        const oldStreamListRecord = z.record(z.string(), oldStringStreamSchema).safeParse(res.data);
+        if (oldStreamListRecord.success) {
+            const data = Object.entries(oldStreamListRecord.data).map(([streamId, streamData]) => ({
+                streamId,
+                ...parseCameraStreamResponse(streamData),
+            }));
+            throw new MigrationError([], data);
+        }
+        const newStreamData = [];
+        const oldStreamData = [];
+        const invalidStreamData = [];
+        for (const streamData of res.data.streamList) {
+            const newStreamParse = streamSchema.safeParse(streamData);
+            if (newStreamParse.success) {
+                newStreamData.push(newStreamParse.data);
+                continue;
+            }
+            const oldStreamParse = oldStringStreamSchemaWithId.safeParse(streamData);
+            if (oldStreamParse.success) {
+                oldStreamData.push({
+                    streamId: oldStreamParse.data.streamId,
+                    ...parseCameraStreamResponse(oldStreamParse.data),
+                });
+                continue;
+            }
+            invalidStreamData.push(streamData);
         }
-        else {
-            throw new Error(await responseStringify(res));
+        if (oldStreamData.length > 0 || invalidStreamData.length > 0) {
+            throw new MigrationError(newStreamData, oldStreamData, invalidStreamData);
+        }
+        return newStreamData;
+    }
+    async setStreamList(streamList, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, { streamList }, {
+            action: 'set',
+        }, options);
+    }
+    async getStream(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get', stream_id: streamId }, options);
+        const newStream = streamSchema.safeParse(res.data);
+        if (newStream.success) {
+            return newStream.data;
         }
+        const oldStream = oldStringStreamSchema.passthrough().parse(res.data);
+        throw new MigrationError([], [{ streamId, ...parseCameraStreamResponse(oldStream) }]);
+    }
+    async setStream(streamId, streamData, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, streamData, {
+            action: 'set',
+            stream_id: streamId,
+        }, options);
+    }
+    async getStreamNetworkStatistics(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);
+        return streamStatsSchema.parse(res.data);
+    }
+    async getSrtStreamStatistics(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/srt_statistics.cgi`, { stream_id: streamId }, options);
+        return srtStreamStatisticsSchema.parse(res.data);
+    }
+    async setStreamEnabled(streamId, enabled, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/set_stream_enabled.cgi`, { stream_id: streamId, enabled: enabled ? 1 : 0 }, options);
+    }
+    async setStreamActive(streamId, active, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/set_stream_active.cgi`, { stream_id: streamId, active: active ? 1 : 0 }, options);
+    }
+    async listFiles(options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_audio.cgi`, { action: 'list' }, options);
+        return audioFileListSchema.parse(res.data);
+    }
+    async uploadFile(formData, storage, options) {
+        await this._post(`${BASE_PATH}/upload_audio.cgi`, formData, {
+            action: 'upload',
+            storage: storage,
+        }, options);
+    }
+    async removeFile(fileParams, options) {
+        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);
+        return storageListSchema.parse(res.data);
+    }
+    async getFileFromCamera(path, options) {
+        return await this._getBlob(`${BASE_PATH}/audio.cgi`, { path }, options);
+    }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
 }
+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),
+    };
+};

package/esm/CamSwitcherAPI.js

@@ -1,125 +1,146 @@
 import { z } from 'zod';
-import { AddNewClipError } from './errors/errors';
-import { isClip, isNullish, responseStringify } from './internal/utils';
-import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, } from './types/CamSwitcherAPI';
-import { networkCameraListSchema } from './types/common';
+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 { isFirmwareVersionAtLeast } from './internal/versionCompare';
-import { FIRMWARE_WITH_BITRATE_MODES_SUPPORT } from './internal/constants';
-const baseUrl = '/local/camswitcher/api';
-export class CamSwitcherAPI {
-    client;
+import { BasicAPI } from './internal/BasicAPI';
+const BASE_PATH = '/local/camswitcher/api';
+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 getProxyUrlPath = () => `${baseUrl}/proxy.cgi`;
-    static getWsEventsUrlPath = () => `/local/camswitcher/events`;
-    static getClipPreviewUrlPath = (id, storage) => `${baseUrl}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
-    async generateSilence(sampleRate, channels) {
-        await this.client.get(`${baseUrl}/generate_silence.cgi`, {
-            sample_rate: sampleRate.toString(),
-            channels,
+        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}`;
+    async checkAPIAvailable(options) {
+        await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
+    }
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return z.boolean().parse(res.data);
+    }
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return networkCameraListSchema.parse(res.data);
+    }
+    async generateSilence(sampleRate, channels, options) {
+        const agent = this.getClient(options?.proxyParams);
+        await agent.get({
+            path: `${BASE_PATH}/generate_silence.cgi`,
+            parameters: {
+                sample_rate: sampleRate.toString(),
+                channels,
+            },
+            timeout: options?.timeout,
         });
     }
-    async checkCameraTime() {
-        const data = await this.get(`${baseUrl}/camera_time.cgi`);
-        return z.boolean().parse(data);
-    }
-    async getIpListFromNetworkCheck() {
-        const data = await this.get(`${baseUrl}/network_camera_list.cgi`);
-        return networkCameraListSchema.parse(data);
-    }
-    async getMaxFps(source) {
-        const data = await this.get(`${baseUrl}/get_max_framerate.cgi`, {
-            video_source: source.toString(),
-        });
-        return z.number().parse(data);
+    async getMaxFps(source, options) {
+        const res = await this._getJson(`${BASE_PATH}/get_max_framerate.cgi`, {
+            video_source: source,
+        }, options);
+        return z.number().parse(res.data);
     }
-    async getStorageInfo() {
-        const data = await this.get(`${baseUrl}/get_storage.cgi`);
-        return storageInfoListSchema.parse(data);
+    async getStorageInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/get_storage.cgi`, undefined, options);
+        return storageInfoListSchema.parse(res.data);
     }
-    async wsAuthorization() {
-        const data = await this.get(`${baseUrl}/ws_authorization.cgi`);
-        return z.string().parse(data);
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        return z.string().parse(res.data);
     }
-    async getOutputInfo() {
-        const data = await this.get(`${baseUrl}/output_info.cgi`);
-        return outputInfoSchema.parse(data);
+    async getOutputInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/output_info.cgi`, undefined, options);
+        return outputInfoSchema.parse(res.data);
     }
-    async getAudioPushInfo() {
-        const data = await this.get(`${baseUrl}/audio_push_info.cgi`);
-        return audioPushInfoSchema.parse(data);
+    async getAudioPushInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/audio_push_info.cgi`, undefined, options);
+        return audioPushInfoSchema.parse(res.data);
     }
-    async getStreamSaveList() {
-        const data = await this.get(`${baseUrl}/streams.cgi`, { action: 'get' });
-        return streamSaveLoadSchema.parse(data);
+    async getStreamSaveList(options) {
+        const res = await this._getJson(`${BASE_PATH}/streams.cgi`, { action: 'get' }, options);
+        return streamSaveLoadSchema.parse(res.data);
     }
-    async getClipSaveList() {
-        const data = await this.get(`${baseUrl}/clips.cgi`, { action: 'get' });
-        return clipSaveLoadSchema.parse(data);
+    async getClipSaveList(options) {
+        const res = await this._getJson(`${BASE_PATH}/clips.cgi`, { action: 'get' }, options);
+        return clipSaveLoadSchema.parse(res.data);
     }
-    async getPlaylistSaveList() {
-        const data = await this.get(`${baseUrl}/playlists.cgi`, { action: 'get' });
-        return playlistSaveLoadSchema.parse(data);
+    async getPlaylistSaveList(options) {
+        const res = await this._getJson(`${BASE_PATH}/playlists.cgi`, { action: 'get' }, options);
+        return playlistSaveLoadSchema.parse(res.data);
     }
-    async getTrackerSaveList() {
-        const data = await this.get(`${baseUrl}/trackers.cgi`, { action: 'get' });
-        return trackerSaveLoadSchema.parse(data);
+    async getTrackerSaveList(options) {
+        const res = await this._getJson(`${BASE_PATH}/trackers.cgi`, { action: 'get' }, options);
+        return trackerSaveLoadSchema.parse(res.data);
     }
-    async setStreamSaveList(data) {
-        return await this.set(`${baseUrl}/streams.cgi`, data, { action: 'set' });
+    async setStreamSaveList(data, options) {
+        await this._post(`${BASE_PATH}/streams.cgi`, JSON.stringify(data), { action: 'set' }, options);
     }
-    async setClipSaveList(data) {
-        return await this.set(`${baseUrl}/clips.cgi`, data, { action: 'set' });
+    async setClipSaveList(data, options) {
+        await this._post(`${BASE_PATH}/clips.cgi`, JSON.stringify(data), { action: 'set' }, options);
     }
-    async setPlaylistSaveList(data) {
-        return await this.set(`${baseUrl}/playlists.cgi`, data, { action: 'set' });
+    async setPlaylistSaveList(data, options) {
+        await this._post(`${BASE_PATH}/playlists.cgi`, JSON.stringify(data), { action: 'set' }, options);
     }
-    async setTrackerSaveList(data) {
-        return await this.set(`${baseUrl}/trackers.cgi`, data, { action: 'set' });
+    async setTrackerSaveList(data, options) {
+        await this._post(`${BASE_PATH}/trackers.cgi`, JSON.stringify(data), { action: 'set' }, options);
     }
-    async playlistSwitch(playlistName) {
-        await this.get(`${baseUrl}/playlist_switch.cgi?playlist_name=${playlistName}`);
+    async playlistSwitch(playlistName, options) {
+        await this._getJson(`${BASE_PATH}/playlist_switch.cgi`, { playlist_name: playlistName }, options);
     }
-    async playlistQueuePush(playlistName) {
-        await this.get(`${baseUrl}/playlist_queue_push.cgi?playlist_name=${playlistName}`);
+    async playlistQueuePush(playlistName, options) {
+        await this._getJson(`${BASE_PATH}/playlist_queue_push.cgi`, { playlist_name: playlistName }, options);
     }
-    async playlistQueueClear() {
-        await this.get(`${baseUrl}/playlist_queue_clear.cgi`);
+    async playlistQueueClear(options) {
+        await this._getJson(`${BASE_PATH}/playlist_queue_clear.cgi`, undefined, options);
     }
-    async playlistQueueList() {
-        const data = await this.get(`${baseUrl}/playlist_queue_list.cgi`);
-        return playlistQueueSchema.parse(data).playlistQueueList;
+    async playlistQueueList(options) {
+        const res = await this._getJson(`${BASE_PATH}/playlist_queue_list.cgi`, undefined, options);
+        return playlistQueueSchema.parse(res.data).playlistQueueList;
     }
-    async playlistQueuePlayNext() {
-        await this.get(`${baseUrl}/playlist_queue_play_next.cgi`);
+    async playlistQueuePlayNext(options) {
+        await this._getJson(`${BASE_PATH}/playlist_queue_play_next.cgi`, undefined, options);
     }
-    async addNewClip(file, clipType, storage, id, fileName) {
+    async addNewClip(file, clipType, storage, clipId, fileName, options) {
+        const path = `${BASE_PATH}/clip_upload.cgi`;
         const formData = new this.CustomFormData();
-        formData.append('clip_name', id);
+        formData.append('clip_name', clipId);
         formData.append('clip_type', clipType);
         formData.append('file', file, fileName);
-        const path = `${baseUrl}/clip_upload.cgi?storage=${storage}`;
-        const res = await this.client.post(path, formData);
+        const agent = this.getClient(options?.proxyParams);
+        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 AddNewClipError(output.message);
         }
     }
-    removeClip(id, storage) {
-        return this.get(`${baseUrl}/clip_remove.cgi`, { clip_name: id, storage });
+    async removeClip(clipId, storage, options) {
+        await this._getJson(`${BASE_PATH}/clip_remove.cgi`, { clip_name: clipId, storage }, options);
     }
-    async getClipList() {
-        const data = await this.get(`${baseUrl}/clip_list.cgi`);
-        return clipListSchema.parse(data).clip_list;
+    async getClipList(options) {
+        const res = await this._getJson(`${BASE_PATH}/clip_list.cgi`, undefined, options);
+        return clipListSchema.parse(res.data).clip_list;
     }
-    setCamSwitchOptions(data, cameraFWVersion) {
-        const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
+    setCamSwitchOptions(data, cameraFWVersion, options) {
+        const bitrateData = {
+            bitrateMode: data.bitrateMode,
+            maximumBitRate: data.maximumBitRate,
+            retentionTime: data.retentionTime,
+            bitRateLimit: data.bitRateLimit,
+        };
+        const bitrateVapixParams = parseBitrateOptionsToVapixParams(cameraFWVersion, data.bitrateMode, bitrateData);
         const saveData = {
             video: {
                 resolution: data.resolution,
@@ -136,9 +157,9 @@ export class CamSwitcherAPI {
             },
             keyboard: data.keyboard,
         };
-        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SETTINGS, saveData);
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SETTINGS, saveData, options);
     }
-    setGlobalAudioSettings(settings) {
+    setGlobalAudioSettings(settings, options) {
         let acceptedType = 'NONE';
         if (settings.type === 'source' && settings.source) {
             if (isClip(settings.source)) {
@@ -154,9 +175,9 @@ export class CamSwitcherAPI {
             clip_name: settings.source,
             storage: settings.storage,
         };
-        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.MASTER_AUDIO, data);
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.MASTER_AUDIO, data, options);
     }
-    setSecondaryAudioSettings(settings) {
+    setSecondaryAudioSettings(settings, options) {
         const data = {
             type: settings.type,
             stream_name: settings.streamName ?? '',
@@ -165,19 +186,19 @@ export class CamSwitcherAPI {
             secondary_audio_level: settings.secondaryAudioLevel,
             master_audio_level: settings.masterAudioLevel,
         };
-        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SECONDARY_AUDIO, data);
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SECONDARY_AUDIO, data, options);
     }
-    setDefaultPlaylist(id) {
-        const value = JSON.stringify({ default_playlist_id: id });
+    setDefaultPlaylist(playlistId, options) {
+        const value = JSON.stringify({ default_playlist_id: playlistId });
         return this.vapixAgent.setParameter({
             [CSW_PARAM_NAMES.DEFAULT_PLAYLIST]: value,
-        }, null);
+        }, options);
     }
-    setPermanentRtspUrlToken(token) {
-        return this.vapixAgent.setParameter({ [CSW_PARAM_NAMES.RTSP_TOKEN]: token }, null);
+    setPermanentRtspUrlToken(token, options) {
+        return this.vapixAgent.setParameter({ [CSW_PARAM_NAMES.RTSP_TOKEN]: token }, options);
     }
-    async getCamSwitchOptions() {
-        const saveData = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SETTINGS);
+    async getCamSwitchOptions(options) {
+        const saveData = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SETTINGS, options);
         if (isNullish(saveData.video)) {
             return saveData;
         }
@@ -202,12 +223,12 @@ export class CamSwitcherAPI {
             keyboard: saveData.keyboard,
         };
     }
-    async getGlobalAudioSettings() {
+    async getGlobalAudioSettings(options) {
         const settings = {
             type: 'fromSource',
             source: 'fromSource',
         };
-        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.MASTER_AUDIO);
+        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.MASTER_AUDIO, options);
         if (res.type === 'STREAM') {
             settings.type = 'source';
             settings.source = res.stream_name;
@@ -217,52 +238,35 @@ export class CamSwitcherAPI {
             settings.source = res.clip_name;
             settings.storage = res.storage;
         }
-        return settings;
+        return globalAudioSettingsSchema.parse(settings);
     }
-    async getSecondaryAudioSettings() {
-        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SECONDARY_AUDIO);
+    async getSecondaryAudioSettings(options) {
+        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SECONDARY_AUDIO, options);
         const settings = {
             type: res.type ?? 'NONE',
             streamName: res.stream_name,
             clipName: res.clip_name,
-            storage: res.storage,
+            storage: res.storage ?? 'SD_DISK',
             secondaryAudioLevel: res.secondary_audio_level ?? 1,
             masterAudioLevel: res.master_audio_level ?? 1,
         };
-        return settings;
+        return secondaryAudioSettingsSchema.parse(settings);
     }
-    async getPermanentRtspUrlToken() {
+    async getPermanentRtspUrlToken(options) {
         const paramName = CSW_PARAM_NAMES.RTSP_TOKEN;
-        const res = await this.vapixAgent.getParameter([paramName], null);
-        return res[paramName] ?? '';
-    }
-    async get(path, parameters = {}) {
-        const res = await this.client.get(path, parameters);
-        if (res.ok) {
-            const d = (await res.json());
-            return d.data;
-        }
-        else {
-            throw new Error(await responseStringify(res));
-        }
+        const res = await this.vapixAgent.getParameter([paramName], options);
+        return z.string().parse(res[paramName] ?? '');
     }
-    async set(path, data, parameters = {}) {
-        const res = await this.client.post(path, JSON.stringify(data), parameters);
-        if (res.ok) {
-            const parsed = await res.json();
-            return parsed.message === 'OK';
-        }
-        else {
-            throw new Error(await responseStringify(res));
-        }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
-    setParamFromCameraJSON(paramName, data) {
+    setParamFromCameraJSON(paramName, data, options) {
         const params = {};
         params[paramName] = JSON.stringify(data);
-        return this.vapixAgent.setParameter(params, null);
+        return this.vapixAgent.setParameter(params, options);
     }
-    async getParamFromCameraAndJSONParse(paramName) {
-        const data = await this.vapixAgent.getParameter([paramName], null);
+    async getParamFromCameraAndJSONParse(paramName, options) {
+        const data = await this.vapixAgent.getParameter([paramName], options);
         if (data[paramName] !== undefined) {
             try {
                 if (data[paramName] === '') {
@@ -273,10 +277,10 @@ export class CamSwitcherAPI {
                 }
             }
             catch {
-                throw new Error('Error: in JSON parsing of ' + paramName + '. Cannot parse: ' + data[paramName]);
+                throw new JsonParseError(paramName, data[paramName]);
             }
         }
-        throw new Error("Error: no parametr '" + paramName + "' was found");
+        throw new ParameterNotFoundError(paramName);
     }
 }
 const CSW_PARAM_NAMES = {
@@ -286,62 +290,3 @@ const CSW_PARAM_NAMES = {
     RTSP_TOKEN: 'Camswitcher.RTSPAccessToken',
     DEFAULT_PLAYLIST: 'Camswitcher.DefaultPlaylist',
 };
-const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
-    if (!isFirmwareVersionAtLeast(firmWareVersion, FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
-        return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
-    }
-    if (bitrateMode === null) {
-        return '';
-    }
-    const data = {
-        VBR: 'videobitratemode=vbr',
-        MBR: `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}`,
-        ABR: `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`,
-    };
-    return data[bitrateMode];
-};
-const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
-    const params = {};
-    const searchParams = new URLSearchParams(bitrateVapixParams);
-    searchParams.forEach((value, key) => {
-        params[key] = value;
-    });
-    const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
-    const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
-    if (hasLowerFw) {
-        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
-        return {
-            bitrateMode: 'MBR',
-            maximumBitRate: maximumBitRate,
-            retentionTime: 1,
-            bitRateLimit: Math.floor(maximumBitRate * 1.1),
-        };
-    }
-    if (bitrateMode === 'ABR') {
-        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
-        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
-        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
-        return {
-            bitrateMode,
-            maximumBitRate,
-            retentionTime,
-            bitRateLimit,
-        };
-    }
-    else if (bitrateMode === 'MBR') {
-        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
-        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
-        return {
-            bitrateMode: bitrateMode,
-            maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,
-            retentionTime: 1,
-            bitRateLimit: Math.floor(maximumBitRate ?? oldMaximumBitrateParamValue * 1.1),
-        };
-    }
-    return {
-        bitrateMode: bitrateMode,
-        retentionTime: 1,
-        maximumBitRate: 0,
-        bitRateLimit: 0,
-    };
-};