camstreamerlib 4.0.0-beta.4 → 4.0.0-beta.41

package/cjs/CamStreamerAPI.js

@@ -1,65 +1,109 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamStreamerAPI = void 0;
-const common_1 = require("./internal/common");
-const DefaultClient_1 = require("./node/DefaultClient");
+exports.parseCameraStreamResponse = exports.CamStreamerAPI = void 0;
+const zod_1 = require("zod");
+const ProxyClient_1 = require("./internal/ProxyClient");
+const utils_1 = require("./internal/utils");
 const CamStreamerAPI_1 = require("./types/CamStreamerAPI");
+const errors_1 = require("./errors/errors");
+const BASE_PATH = '/local/camstreamer';
 class CamStreamerAPI {
     client;
-    constructor(options = {}) {
-        if ((0, common_1.isClient)(options)) {
-            this.client = options;
+    constructor(client) {
+        this.client = client;
+    }
+    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 errors_1.WsAuthorizationError(res.message);
         }
-        else {
-            this.client = new DefaultClient_1.DefaultClient(options);
+        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 errors_1.UtcTimeFetchError(res.message);
         }
+        return zod_1.z.number().parse(res.data);
     }
-    async getStreamList() {
-        const streamListRes = await this.get('/local/camstreamer/stream/list.cgi');
-        return CamStreamerAPI_1.streamListSchema.parse(streamListRes.data);
+    async getStreamList(options) {
+        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);
+            streamList[streamId] = (0, exports.parseCameraStreamResponse)(data);
+        }
+        return streamList;
     }
-    async getStream(streamID) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
-        return CamStreamerAPI_1.streamAttributesSchema.parse(stream.data);
+    async getStream(streamId, options) {
+        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) {
-        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 zod_1.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();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
 }
 exports.CamStreamerAPI = CamStreamerAPI;
+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),
+    };
+};
+exports.parseCameraStreamResponse = parseCameraStreamResponse;

package/cjs/CamSwitcherAPI.js

@@ -3,124 +3,142 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamSwitcherAPI = void 0;
 const zod_1 = require("zod");
 const errors_1 = require("./errors/errors");
-const common_1 = require("./internal/common");
+const utils_1 = require("./internal/utils");
 const CamSwitcherAPI_1 = require("./types/CamSwitcherAPI");
-const common_2 = require("./types/common");
+const common_1 = require("./types/common");
 const VapixAPI_1 = require("./VapixAPI");
 const versionCompare_1 = require("./internal/versionCompare");
-const utils_1 = require("./internal/utils");
 const constants_1 = require("./internal/constants");
-const baseUrl = '/local/camswitcher/api';
+const ProxyClient_1 = require("./internal/ProxyClient");
+const BASE_PATH = '/local/camswitcher/api';
 class CamSwitcherAPI {
     client;
+    CustomFormData;
     vapixAgent;
-    constructor(client) {
+    constructor(client, CustomFormData = FormData) {
         this.client = client;
-        this.vapixAgent = new VapixAPI_1.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.CustomFormData = CustomFormData;
+        this.vapixAgent = new VapixAPI_1.VapixAPI(client);
+    }
+    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;
+    }
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return zod_1.z.boolean().parse(res.data);
+    }
+    async getNetworkCameraList(options) {
+        const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return common_1.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 zod_1.z.boolean().parse(data);
-    }
-    async getIpListFromNetworkCheck() {
-        const data = await this.get(`${baseUrl}/network_camera_list.cgi`);
-        return common_2.networkCameraListSchema.parse(data);
+    async getMaxFps(source, options) {
+        const res = await this._getJson(`${BASE_PATH}/get_max_framerate.cgi`, {
+            video_source: source,
+        }, options);
+        return zod_1.z.number().parse(res.data);
     }
-    async getMaxFps(source) {
-        const data = await this.get(`${baseUrl}/get_max_framerate.cgi`, {
-            video_source: source.toString(),
-        });
-        return zod_1.z.number().parse(data);
-    }
-    async getStorageInfo() {
-        const data = await this.get(`${baseUrl}/get_storage.cgi`);
-        return CamSwitcherAPI_1.storageInfoListSchema.parse(data);
+    async getStorageInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/get_storage.cgi`, undefined, options);
+        return CamSwitcherAPI_1.storageInfoListSchema.parse(res.data);
     }
-    async wsAuthorization() {
-        const data = await this.get(`${baseUrl}/ws_authorization.cgi`);
-        return zod_1.z.string().parse(data);
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        return zod_1.z.string().parse(res.data);
     }
-    async getOutputInfo() {
-        const data = await this.get(`${baseUrl}/output_info.cgi`);
-        return CamSwitcherAPI_1.outputInfoSchema.parse(data);
+    async getOutputInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/output_info.cgi`, undefined, options);
+        return CamSwitcherAPI_1.outputInfoSchema.parse(res.data);
     }
-    async getAudioPushInfo() {
-        const data = await this.get(`${baseUrl}/audio_push_info.cgi`);
-        return CamSwitcherAPI_1.audioPushInfoSchema.parse(data);
+    async getAudioPushInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/audio_push_info.cgi`, undefined, options);
+        return CamSwitcherAPI_1.audioPushInfoSchema.parse(res.data);
     }
-    async getStreamSaveList() {
-        const data = await this.get(`${baseUrl}/streams.cgi`, { action: 'get' });
-        return CamSwitcherAPI_1.streamSaveLoadSchema.parse(data);
+    async getStreamSaveList(options) {
+        const res = await this._getJson(`${BASE_PATH}/streams.cgi`, { action: 'get' }, options);
+        return CamSwitcherAPI_1.streamSaveLoadSchema.parse(res.data);
     }
-    async getClipSaveList() {
-        const data = await this.get(`${baseUrl}/clips.cgi`, { action: 'get' });
-        return CamSwitcherAPI_1.clipSaveLoadSchema.parse(data);
+    async getClipSaveList(options) {
+        const res = await this._getJson(`${BASE_PATH}/clips.cgi`, { action: 'get' }, options);
+        return CamSwitcherAPI_1.clipSaveLoadSchema.parse(res.data);
     }
-    async getPlaylistSaveList() {
-        const data = await this.get(`${baseUrl}/playlists.cgi`, { action: 'get' });
-        return CamSwitcherAPI_1.playlistSaveLoadSchema.parse(data);
+    async getPlaylistSaveList(options) {
+        const res = await this._getJson(`${BASE_PATH}/playlists.cgi`, { action: 'get' }, options);
+        return CamSwitcherAPI_1.playlistSaveLoadSchema.parse(res.data);
     }
-    async getTrackerSaveList() {
-        const data = await this.get(`${baseUrl}/trackers.cgi`, { action: 'get' });
-        return CamSwitcherAPI_1.trackerSaveLoadSchema.parse(data);
+    async getTrackerSaveList(options) {
+        const res = await this._getJson(`${BASE_PATH}/trackers.cgi`, { action: 'get' }, options);
+        return CamSwitcherAPI_1.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`, 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`, 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`, 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`, 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 CamSwitcherAPI_1.playlistQueueSchema.parse(data).playlistQueueList;
+    async playlistQueueList(options) {
+        const res = await this._getJson(`${BASE_PATH}/playlist_queue_list.cgi`, undefined, options);
+        return CamSwitcherAPI_1.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) {
-        const formData = new FormData();
-        formData.append('clip_name', id);
+    async addNewClip(file, clipType, storage, clipId, fileName, options) {
+        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 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 errors_1.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 CamSwitcherAPI_1.clipListSchema.parse(data).clip_list;
+    async getClipList(options) {
+        const res = await this._getJson(`${BASE_PATH}/clip_list.cgi`, undefined, options);
+        return CamSwitcherAPI_1.clipListSchema.parse(res.data).clip_list;
     }
-    setCamSwitchOptions(data, cameraFWVersion) {
+    setCamSwitchOptions(data, cameraFWVersion, options) {
         const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
         const saveData = {
             video: {
@@ -138,9 +156,9 @@ 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 ((0, utils_1.isClip)(settings.source)) {
@@ -156,9 +174,9 @@ 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 ?? '',
@@ -167,34 +185,34 @@ 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);
-        if ((0, common_1.isNullish)(saveData.video)) {
+    async getCamSwitchOptions(options) {
+        const saveData = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SETTINGS, options);
+        if ((0, utils_1.isNullish)(saveData.video)) {
             return saveData;
         }
-        if (!(0, common_1.isNullish)(saveData.video?.bitrateVapixParams)) {
+        if (!(0, utils_1.isNullish)(saveData.video?.bitrateVapixParams)) {
             const bitrateOptions = parseVapixParamsToBitrateOptions(saveData.video.bitrateVapixParams);
             saveData.video.bitrateMode = bitrateOptions.bitrateMode;
             saveData.video.maximumBitRate = bitrateOptions.maximumBitRate;
             saveData.video.retentionTime = bitrateOptions.retentionTime;
             saveData.video.bitRateLimit = bitrateOptions.bitRateLimit;
         }
-        if (!(0, common_1.isNullish)(saveData.video?.bitrateLimit)) {
+        if (!(0, utils_1.isNullish)(saveData.video?.bitrateLimit)) {
             saveData.video.maximumBitRate = saveData.video.bitrateLimit;
             saveData.video.bitrateMode = 'MBR';
         }
-        if (!(0, common_1.isNullish)(saveData.video?.videoClipQuality)) {
+        if (!(0, utils_1.isNullish)(saveData.video?.videoClipQuality)) {
             saveData.video.maximumBitRate = saveData.video.videoClipQuality;
         }
         return {
@@ -204,12 +222,12 @@ 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;
@@ -219,10 +237,10 @@ class CamSwitcherAPI {
             settings.source = res.clip_name;
             settings.storage = res.storage;
         }
-        return settings;
+        return CamSwitcherAPI_1.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,
@@ -231,40 +249,40 @@ class CamSwitcherAPI {
             secondaryAudioLevel: res.secondary_audio_level ?? 1,
             masterAudioLevel: res.master_audio_level ?? 1,
         };
-        return settings;
+        return CamSwitcherAPI_1.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] ?? '';
+        const res = await this.vapixAgent.getParameter([paramName], options);
+        return zod_1.z.string().parse(res[paramName] ?? '');
     }
-    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) {
-            const d = (await res.json());
-            return d.data;
+            return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async set(path, data, parameters = {}) {
-        const res = await this.client.post(path, JSON.stringify(data), parameters);
+    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) {
-            const parsed = await res.json();
-            return parsed.message === 'OK';
+            return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    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] === '') {
@@ -275,10 +293,10 @@ class CamSwitcherAPI {
                 }
             }
             catch {
-                throw new Error('Error: in JSON parsing of ' + paramName + '. Cannot parse: ' + data[paramName]);
+                throw new errors_1.JsonParseError(paramName, data[paramName]);
             }
         }
-        throw new Error("Error: no parametr '" + paramName + "' was found");
+        throw new errors_1.ParameterNotFoundError(paramName);
     }
 }
 exports.CamSwitcherAPI = CamSwitcherAPI;
@@ -293,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 = {

package/cjs/CamSwitcherEvents.js

@@ -1,67 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamSwitcherEvents = void 0;
+const WsEvents_1 = require("./internal/WsEvents");
 const CamSwitcherEvents_1 = require("./types/CamSwitcherEvents");
-class CamSwitcherEvents {
-    isDestroyed = false;
-    ws = null;
-    listeners = {};
-    setWebsocket(ws) {
-        if (this.ws) {
-            this.ws.destroy();
-        }
-        this.ws = ws;
-        this.ws.onmessage = (e) => this.onMessage(e);
-    }
-    resendInitData() {
-        const request = {
-            command: 'sendInitData',
-        };
-        this.ws?.send(JSON.stringify(request));
-    }
-    addListener(type, listener, id) {
-        const typeList = this.listeners[type];
-        if (typeList === undefined) {
-            this.listeners[type] = { [id]: listener };
-            return;
-        }
-        typeList[id] = listener;
-    }
-    removeListener(type, id) {
-        const typeList = this.listeners[type];
-        if (typeList) {
-            delete typeList[id];
-        }
-    }
-    onMessage(evt) {
-        if (this.isDestroyed) {
-            return;
-        }
-        try {
-            const eventData = JSON.parse(evt.data);
-            const data = CamSwitcherEvents_1.cswEventsSchema.parse(eventData);
-            if (data.type === 'init') {
-                this.processMessage(data.data, true);
-                return;
-            }
-            this.processMessage(data, false);
-        }
-        catch (error) {
-            console.error('Error parsing event data:', evt.data, error);
-        }
-    }
-    processMessage(event, isInit) {
-        const listeners = this.listeners[event.type];
-        const list = Object.values(listeners ?? {});
-        list.forEach((listener) => listener(event, isInit));
-    }
-    destroy() {
-        this.isDestroyed = true;
-        if (this.ws) {
-            this.ws.destroy();
-            this.ws = null;
-        }
-        this.listeners = {};
+class CamSwitcherEvents extends WsEvents_1.WsEvents {
+    constructor(ws) {
+        super(CamSwitcherEvents_1.cswEventsSchema, ws);
     }
 }
 exports.CamSwitcherEvents = CamSwitcherEvents;