camstreamerlib 4.0.0-beta.3 → 4.0.0-beta.31

package/cjs/CamSwitcherAPI.d.ts

@@ -1,46 +1,52 @@
-import { IClient } from './internal/common';
+import { IClient, TResponse } from './internal/types';
 import { TAudioPushInfo, TOutputInfo, TStorageInfo, TStreamSaveList, TClipList, TStreamSaveLoadList, TClipSaveLoadList, TPlaylistSaveLoadList, TTrackerSaveList, TrackerSaveLoadList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
-import { TAudioChannel, TNetworkCamera, TStorageType } from './types/common';
-export declare class CamSwitcherAPI<Client extends IClient = IClient> {
+import { TAudioChannel, THttpRequestOptions, TNetworkCamera, TProxyParams, TStorageType } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     client: Client;
+    private CustomFormData;
     private vapixAgent;
-    constructor(client: Client);
+    constructor(client: Client, CustomFormData?: {
+        new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
+        prototype: FormData;
+    });
     static getProxyUrlPath: () => string;
     static getWsEventsUrlPath: () => string;
     static getClipPreviewUrlPath: (id: string, storage: TStorageType) => string;
-    generateSilence(sampleRate: number, channels: TAudioChannel): Promise<void>;
-    checkCameraTime(): Promise<boolean>;
-    getIpListFromNetworkCheck(): Promise<TNetworkCamera[]>;
-    getMaxFps(source: number): Promise<number>;
-    getStorageInfo(): Promise<TStorageInfo[]>;
-    wsAuthorization(): Promise<string>;
-    getOutputInfo(): Promise<TOutputInfo>;
-    getAudioPushInfo(): Promise<TAudioPushInfo>;
-    getStreamSaveList(): Promise<TStreamSaveLoadList>;
-    getClipSaveList(): Promise<TClipSaveLoadList>;
-    getPlaylistSaveList(): Promise<TPlaylistSaveLoadList>;
-    getTrackerSaveList(): Promise<TrackerSaveLoadList>;
-    setStreamSaveList(data: TStreamSaveList): Promise<boolean>;
-    setClipSaveList(data: TClipSaveList): Promise<boolean>;
-    setPlaylistSaveList(data: TPlaylistSaveList): Promise<boolean>;
-    setTrackerSaveList(data: TTrackerSaveList): Promise<boolean>;
-    playlistSwitch(playlistName: string): Promise<void>;
-    playlistQueuePush(playlistName: string): Promise<void>;
-    playlistQueueClear(): Promise<void>;
-    playlistQueueList(): Promise<string[]>;
-    playlistQueuePlayNext(): Promise<void>;
-    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string): Promise<void>;
-    removeClip(id: string, storage: TStorageType): Promise<any>;
-    getClipList(): Promise<TClipList>;
-    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string): Promise<boolean>;
-    setGlobalAudioSettings(settings: TGlobalAudioSettings): Promise<boolean>;
-    setSecondaryAudioSettings(settings: TSecondaryAudioSettings): Promise<boolean>;
-    setDefaultPlaylist(id: string): Promise<boolean>;
-    setPermanentRtspUrlToken(token: string): Promise<boolean>;
-    getCamSwitchOptions(): Promise<Partial<TCameraOptions>>;
-    getGlobalAudioSettings(): Promise<TGlobalAudioSettings>;
-    getSecondaryAudioSettings(): Promise<TSecondaryAudioSettings>;
-    getPermanentRtspUrlToken(): Promise<string>;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
+    getMaxFps(source: number, options?: THttpRequestOptions): Promise<number>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<TStorageInfo[]>;
+    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getOutputInfo(options?: THttpRequestOptions): Promise<TOutputInfo>;
+    getAudioPushInfo(options?: THttpRequestOptions): Promise<TAudioPushInfo>;
+    getStreamSaveList(options?: THttpRequestOptions): Promise<TStreamSaveLoadList>;
+    getClipSaveList(options?: THttpRequestOptions): Promise<TClipSaveLoadList>;
+    getPlaylistSaveList(options?: THttpRequestOptions): Promise<TPlaylistSaveLoadList>;
+    getTrackerSaveList(options?: THttpRequestOptions): Promise<TrackerSaveLoadList>;
+    setStreamSaveList(data: TStreamSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    setClipSaveList(data: TClipSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    setPlaylistSaveList(data: TPlaylistSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    setTrackerSaveList(data: TTrackerSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    playlistSwitch(playlistName: string, options?: THttpRequestOptions): Promise<void>;
+    playlistQueuePush(playlistName: string, options?: THttpRequestOptions): Promise<void>;
+    playlistQueueClear(options?: THttpRequestOptions): Promise<void>;
+    playlistQueueList(options?: THttpRequestOptions): Promise<string[]>;
+    playlistQueuePlayNext(options?: THttpRequestOptions): Promise<void>;
+    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
+    removeClip(id: string, storage: TStorageType, options?: THttpRequestOptions): Promise<any>;
+    getClipList(options?: THttpRequestOptions): Promise<TClipList>;
+    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<boolean>;
+    setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<boolean>;
+    setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<boolean>;
+    setDefaultPlaylist(id: string, options?: THttpRequestOptions): Promise<boolean>;
+    setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<boolean>;
+    getCamSwitchOptions(options?: THttpRequestOptions): Promise<Partial<TCameraOptions>>;
+    getGlobalAudioSettings(options?: THttpRequestOptions): Promise<TGlobalAudioSettings>;
+    getSecondaryAudioSettings(options?: THttpRequestOptions): Promise<TSecondaryAudioSettings>;
+    getPermanentRtspUrlToken(options?: THttpRequestOptions): Promise<string>;
     private get;
     private set;
     private setParamFromCameraJSON;

package/cjs/CamSwitcherAPI.js

@@ -3,124 +3,135 @@ 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, () => '');
+        this.CustomFormData = CustomFormData;
+        this.vapixAgent = new VapixAPI_1.VapixAPI(client);
     }
-    static getProxyUrlPath = () => `${baseUrl}/proxy.cgi`;
+    static getProxyUrlPath = () => `${BASE_PATH}/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,
+    static getClipPreviewUrlPath = (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 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`);
+    async checkCameraTime(options) {
+        const data = await this.get(`${BASE_PATH}/camera_time.cgi`, undefined, options);
         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 getNetworkCameraList(options) {
+        const data = await this.get(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return common_1.networkCameraListSchema.parse(data);
     }
-    async getMaxFps(source) {
-        const data = await this.get(`${baseUrl}/get_max_framerate.cgi`, {
+    async getMaxFps(source, options) {
+        const data = await this.get(`${BASE_PATH}/get_max_framerate.cgi`, {
             video_source: source.toString(),
-        });
+        }, options);
         return zod_1.z.number().parse(data);
     }
-    async getStorageInfo() {
-        const data = await this.get(`${baseUrl}/get_storage.cgi`);
+    async getStorageInfo(options) {
+        const data = await this.get(`${BASE_PATH}/get_storage.cgi`, undefined, options);
         return CamSwitcherAPI_1.storageInfoListSchema.parse(data);
     }
-    async wsAuthorization() {
-        const data = await this.get(`${baseUrl}/ws_authorization.cgi`);
+    async wsAuthorization(options) {
+        const data = await this.get(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
         return zod_1.z.string().parse(data);
     }
-    async getOutputInfo() {
-        const data = await this.get(`${baseUrl}/output_info.cgi`);
+    async getOutputInfo(options) {
+        const data = await this.get(`${BASE_PATH}/output_info.cgi`, undefined, options);
         return CamSwitcherAPI_1.outputInfoSchema.parse(data);
     }
-    async getAudioPushInfo() {
-        const data = await this.get(`${baseUrl}/audio_push_info.cgi`);
+    async getAudioPushInfo(options) {
+        const data = await this.get(`${BASE_PATH}/audio_push_info.cgi`, undefined, options);
         return CamSwitcherAPI_1.audioPushInfoSchema.parse(data);
     }
-    async getStreamSaveList() {
-        const data = await this.get(`${baseUrl}/streams.cgi`, { action: 'get' });
+    async getStreamSaveList(options) {
+        const data = await this.get(`${BASE_PATH}/streams.cgi`, { action: 'get' }, options);
         return CamSwitcherAPI_1.streamSaveLoadSchema.parse(data);
     }
-    async getClipSaveList() {
-        const data = await this.get(`${baseUrl}/clips.cgi`, { action: 'get' });
+    async getClipSaveList(options) {
+        const data = await this.get(`${BASE_PATH}/clips.cgi`, { action: 'get' }, options);
         return CamSwitcherAPI_1.clipSaveLoadSchema.parse(data);
     }
-    async getPlaylistSaveList() {
-        const data = await this.get(`${baseUrl}/playlists.cgi`, { action: 'get' });
+    async getPlaylistSaveList(options) {
+        const data = await this.get(`${BASE_PATH}/playlists.cgi`, { action: 'get' }, options);
         return CamSwitcherAPI_1.playlistSaveLoadSchema.parse(data);
     }
-    async getTrackerSaveList() {
-        const data = await this.get(`${baseUrl}/trackers.cgi`, { action: 'get' });
+    async getTrackerSaveList(options) {
+        const data = await this.get(`${BASE_PATH}/trackers.cgi`, { action: 'get' }, options);
         return CamSwitcherAPI_1.trackerSaveLoadSchema.parse(data);
     }
-    async setStreamSaveList(data) {
-        return await this.set(`${baseUrl}/streams.cgi`, data, { action: 'set' });
+    async setStreamSaveList(data, options) {
+        return await this.set(`${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) {
+        return await this.set(`${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) {
+        return await this.set(`${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) {
+        return await this.set(`${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.get(`${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.get(`${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.get(`${BASE_PATH}/playlist_queue_clear.cgi`, undefined, options);
     }
-    async playlistQueueList() {
-        const data = await this.get(`${baseUrl}/playlist_queue_list.cgi`);
+    async playlistQueueList(options) {
+        const data = await this.get(`${BASE_PATH}/playlist_queue_list.cgi`, undefined, options);
         return CamSwitcherAPI_1.playlistQueueSchema.parse(data).playlistQueueList;
     }
-    async playlistQueuePlayNext() {
-        await this.get(`${baseUrl}/playlist_queue_play_next.cgi`);
+    async playlistQueuePlayNext(options) {
+        await this.get(`${BASE_PATH}/playlist_queue_play_next.cgi`, undefined, options);
     }
-    async addNewClip(file, clipType, storage, id, fileName) {
-        const formData = new FormData();
+    async addNewClip(file, clipType, storage, id, fileName, options) {
+        const path = `${BASE_PATH}/clip_upload.cgi?storage=${storage}`;
+        const formData = new this.CustomFormData();
         formData.append('clip_name', id);
         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, 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 });
+    removeClip(id, storage, options) {
+        return this.get(`${BASE_PATH}/clip_remove.cgi`, { clip_name: id, storage }, options);
     }
-    async getClipList() {
-        const data = await this.get(`${baseUrl}/clip_list.cgi`);
+    async getClipList(options) {
+        const data = await this.get(`${BASE_PATH}/clip_list.cgi`, undefined, options);
         return CamSwitcherAPI_1.clipListSchema.parse(data).clip_list;
     }
-    setCamSwitchOptions(data, cameraFWVersion) {
+    setCamSwitchOptions(data, cameraFWVersion, options) {
         const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
         const saveData = {
             video: {
@@ -138,9 +149,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 +167,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 +178,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) {
+    setDefaultPlaylist(id, options) {
         const value = JSON.stringify({ default_playlist_id: id });
         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 +215,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;
@@ -221,8 +232,8 @@ class CamSwitcherAPI {
         }
         return 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,
@@ -233,38 +244,40 @@ class CamSwitcherAPI {
         };
         return settings;
     }
-    async getPermanentRtspUrlToken() {
+    async getPermanentRtspUrlToken(options) {
         const paramName = CSW_PARAM_NAMES.RTSP_TOKEN;
-        const res = await this.vapixAgent.getParameter([paramName], null);
+        const res = await this.vapixAgent.getParameter([paramName], options);
         return res[paramName] ?? '';
     }
-    async get(path, parameters = {}) {
-        const res = await this.client.get(path, parameters);
+    async get(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;
         }
         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 set(path, data, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data: JSON.stringify(data), parameters, timeout: options?.timeout });
         if (res.ok) {
             const parsed = await res.json();
             return parsed.message === 'OK';
         }
         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] === '') {
@@ -296,16 +309,12 @@ const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, c
     if (bitrateMode === null) {
         return '';
     }
-    if (bitrateMode === 'VBR') {
-        return 'videobitratemode=vbr';
-    }
-    if (bitrateMode === 'MBR') {
-        return `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}`;
-    }
-    if (bitrateMode === 'ABR') {
-        return `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`;
-    }
-    throw new Error('Unknown bitrateMode param in getVapixParams method.');
+    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 = {};
@@ -316,7 +325,7 @@ const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
     const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
     const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
     if (hasLowerFw) {
-        const maximumBitRate = parseInt(params['videomaxbitrate'], 10);
+        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
         return {
             bitrateMode: 'MBR',
             maximumBitRate: maximumBitRate,
@@ -325,19 +334,19 @@ const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
         };
     }
     if (bitrateMode === 'ABR') {
-        const maximumBitRate = parseInt(params['videoabrtargetbitrate'], 10);
-        const retentionTime = parseInt(params['videoabrretentiontime'], 10);
-        const bitrateLimit = parseInt(params['videoabrmaxbitrate'], 10);
+        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
+        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
+        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
         return {
-            bitrateMode: bitrateMode,
-            maximumBitRate: maximumBitRate,
-            retentionTime: retentionTime,
-            bitRateLimit: bitrateLimit,
+            bitrateMode,
+            maximumBitRate,
+            retentionTime,
+            bitRateLimit,
         };
     }
     else if (bitrateMode === 'MBR') {
-        const maximumBitRate = parseInt(params['videomaxbitrate'], 10);
-        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'], 10);
+        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
+        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
         return {
             bitrateMode: bitrateMode,
             maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,

package/cjs/CamSwitcherEvents.d.ts

@@ -1,4 +1,4 @@
-import { IWebsocket } from './internal/common';
+import { IWebsocket } from './internal/types';
 import { TCamSwitcherEventOfType, TCamSwitcherEventType } from './types/CamSwitcherEvents';
 type TListenerFunction<T extends TCamSwitcherEventType> = (data: TCamSwitcherEventOfType<T>, isInit: boolean) => void;
 export declare class CamSwitcherEvents<Event extends {

package/cjs/PlaneTrackerAPI.d.ts

@@ -0,0 +1,43 @@
+import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
+import { ICAO, TApiUser, TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
+import { THttpRequestOptions, TProxyParams } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+export declare class PlaneTrackerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    private client;
+    private apiUser;
+    constructor(client: Client, apiUser: TApiUser);
+    static getProxyUrlPath: () => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    resetPtzCalibration: (options?: THttpRequestOptions) => Promise<TResponse>;
+    resetFocusCalibration: (options?: THttpRequestOptions) => Promise<TResponse>;
+    serverRunCheck: (options?: THttpRequestOptions) => Promise<TResponse>;
+    getLiveViewAlias: (rtspUrl: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    fetchCameraSettings: (options?: THttpRequestOptions) => Promise<any>;
+    setCameraSettings: (settingsJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    fetchServerSettings: (options?: THttpRequestOptions) => Promise<any>;
+    exportAppSettings: (dataType: TExportDataType, options?: THttpRequestOptions) => Promise<TBlobResponse<Client>>;
+    importAppSettings: (dataType: TImportDataType, formData: FormData, options?: THttpRequestOptions) => Promise<TResponse>;
+    fetchFlightInfo: (icao: ICAO, options?: THttpRequestOptions) => Promise<any>;
+    getTrackingMode: (options?: THttpRequestOptions) => Promise<any>;
+    setTrackingMode: (modeJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    startTrackingPlane: (icao: ICAO, options?: THttpRequestOptions) => Promise<TResponse>;
+    stopTrackingPlane: (options?: THttpRequestOptions) => Promise<TResponse>;
+    getPriorityList: (options?: THttpRequestOptions) => Promise<any>;
+    setPriorityList: (priorityListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    getWhiteList: (options?: THttpRequestOptions) => Promise<any>;
+    setWhiteList: (whiteListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    getBlackList: (options?: THttpRequestOptions) => Promise<any>;
+    setBlackList: (blackListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    fetchMapInfo: (options?: THttpRequestOptions) => Promise<any>;
+    getZones: (options?: THttpRequestOptions) => Promise<any>;
+    setZones: (zonesJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    goToCoordinates: (lat: number, lon: number, alt?: number, options?: THttpRequestOptions) => Promise<TResponse>;
+    checkGenetecConnection: (params: TParameters, options?: THttpRequestOptions) => Promise<TResponse>;
+    getGenetecCameraList: (params: TParameters, options?: THttpRequestOptions) => Promise<any>;
+    private _getJson;
+    private _getBlob;
+    private parseBlobResponse;
+    private _postJsonEncoded;
+    private _postUrlEncoded;
+}