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

package/esm/CamSwitcherAPI.js

@@ -1,123 +1,134 @@
 import { z } from 'zod';
 import { AddNewClipError } from './errors/errors';
-import { isNullish, responseStringify } from './internal/common';
+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 { networkCameraListSchema, } from './types/common';
 import { VapixAPI } from './VapixAPI';
 import { isFirmwareVersionAtLeast } from './internal/versionCompare';
-import { isClip } from './internal/utils';
 import { FIRMWARE_WITH_BITRATE_MODES_SUPPORT } from './internal/constants';
-const baseUrl = '/local/camswitcher/api';
+import { ProxyClient } from './internal/ProxyClient';
+const BASE_PATH = '/local/camswitcher/api';
 export class CamSwitcherAPI {
     client;
+    CustomFormData;
     vapixAgent;
-    constructor(client) {
+    constructor(client, CustomFormData = FormData) {
         this.client = client;
-        this.vapixAgent = new VapixAPI(client, () => '');
+        this.CustomFormData = CustomFormData;
+        this.vapixAgent = new 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(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 z.boolean().parse(data);
     }
-    async getIpListFromNetworkCheck() {
-        const data = await this.get(`${baseUrl}/network_camera_list.cgi`);
+    async getNetworkCameraList(options) {
+        const data = await this.get(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
         return 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 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 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 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 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 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 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 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 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 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 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 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 clipListSchema.parse(data).clip_list;
     }
-    setCamSwitchOptions(data, cameraFWVersion) {
+    setCamSwitchOptions(data, cameraFWVersion, options) {
         const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
         const saveData = {
             video: {
@@ -135,9 +146,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)) {
@@ -153,9 +164,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 ?? '',
@@ -164,19 +175,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) {
+    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);
+    async getCamSwitchOptions(options) {
+        const saveData = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SETTINGS, options);
         if (isNullish(saveData.video)) {
             return saveData;
         }
@@ -201,12 +212,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;
@@ -218,8 +229,8 @@ export 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,
@@ -230,13 +241,14 @@ export 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;
@@ -245,8 +257,9 @@ export class CamSwitcherAPI {
             throw new Error(await 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';
@@ -255,13 +268,13 @@ export class CamSwitcherAPI {
             throw new Error(await 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] === '') {
@@ -292,16 +305,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 = {};
@@ -312,7 +321,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,
@@ -321,19 +330,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/esm/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/esm/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;
+}

package/esm/PlaneTrackerAPI.js

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+import { paramToUrl, responseStringify } from './internal/utils';
+import { ParsingBlobError } from './errors/errors';
+import { ProxyClient } from './internal/ProxyClient';
+const BASE_PATH = '/local/planetracker';
+export class PlaneTrackerAPI {
+    client;
+    apiUser;
+    constructor(client, apiUser) {
+        this.client = client;
+        this.apiUser = apiUser;
+    }
+    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async checkCameraTime(options) {
+        const response = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return z.boolean().parse(response.state);
+    }
+    resetPtzCalibration = async (options) => {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/resetPtzCalibration.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
+    };
+    resetFocusCalibration = async (options) => {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/resetFocusCalibration.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
+    };
+    serverRunCheck = async (options) => {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({ path: `${BASE_PATH}/package/serverRunCheck.cgi`, timeout: options?.timeout });
+    };
+    getLiveViewAlias = async (rtspUrl, options) => {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/getLiveViewAlias.cgi`,
+            parameters: { rtsp_url: rtspUrl },
+            timeout: options?.timeout,
+        });
+    };
+    fetchCameraSettings = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package_camera_settings.cgi`, { action: 'get' }, options);
+    };
+    setCameraSettings = async (settingsJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settingsJsonString, {
+            action: 'set',
+        }, options);
+    };
+    fetchServerSettings = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package_server_settings.cgi`, { action: 'get' }, options);
+    };
+    exportAppSettings = async (dataType, options) => {
+        return await this._getBlob(`${BASE_PATH}/package_data.cgi`, { action: 'EXPORT', dataType }, options);
+    };
+    importAppSettings = async (dataType, formData, options) => {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.post({
+            path: `${BASE_PATH}/package_data.cgi`,
+            data: formData,
+            parameters: { action: 'IMPORT', dataType },
+            timeout: options?.timeout,
+        });
+    };
+    fetchFlightInfo = async (icao, options) => {
+        return await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao: encodeURIComponent(icao) }, options);
+    };
+    getTrackingMode = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getTrackingMode.cgi`, undefined, options);
+    };
+    setTrackingMode = async (modeJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, modeJsonString, this.apiUser, options);
+    };
+    startTrackingPlane = async (icao, options) => {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/trackIcao.cgi`,
+            parameters: { icao, ...this.apiUser },
+            timeout: options?.timeout,
+        });
+    };
+    stopTrackingPlane = async (options) => {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/resetIcao.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
+    };
+    getPriorityList = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);
+    };
+    setPriorityList = async (priorityListJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, priorityListJsonString, this.apiUser, options);
+    };
+    getWhiteList = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
+    };
+    setWhiteList = async (whiteListJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, whiteListJsonString, this.apiUser, options);
+    };
+    getBlackList = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getBlackList.cgi`, undefined, options);
+    };
+    setBlackList = async (blackListJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, blackListJsonString, this.apiUser, options);
+    };
+    fetchMapInfo = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getMapInfo.cgi`, undefined, options);
+    };
+    getZones = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getZones.cgi`, undefined, options);
+    };
+    setZones = async (zonesJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, zonesJsonString, this.apiUser, options);
+    };
+    goToCoordinates = async (lat, lon, alt, options) => {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/goToCoordinates.cgi`,
+            parameters: { lat, lon, alt, ...this.apiUser },
+            timeout: options?.timeout,
+        });
+    };
+    checkGenetecConnection = async (params, options) => {
+        return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, params, options);
+    };
+    getGenetecCameraList = async (params, options) => {
+        const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, params, options);
+        return await res.json();
+    };
+    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 responseStringify(res));
+        }
+    }
+    async _getBlob(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path,
+            parameters,
+            timeout: options?.timeout,
+        });
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new ParsingBlobError(err);
+        }
+    }
+    async _postJsonEncoded(path, data, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data,
+            parameters,
+            headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
+            timeout: options?.timeout,
+        });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async _postUrlEncoded(path, params, options) {
+        const data = paramToUrl(params);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data,
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            timeout: options?.timeout,
+        });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+}