camstreamerlib 4.0.0-beta.8 → 4.0.0-beta.80

package/esm/CamSwitcherAPI.js

@@ -1,13 +1,13 @@
 import { z } from 'zod';
-import { AddNewClipError } from './errors/errors';
-import { isNullish, responseStringify } from './internal/common';
-import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, } from './types/CamSwitcherAPI';
-import { networkCameraListSchema } from './types/common';
+import { AddNewClipError, JsonParseError, ParameterNotFoundError, ErrorWithResponse } from './errors/errors';
+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 { 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;
@@ -15,111 +15,127 @@ export class CamSwitcherAPI {
     constructor(client, CustomFormData = FormData) {
         this.client = 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}`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    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) {
+    setCamSwitchOptions(data, cameraFWVersion, options) {
         const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
         const saveData = {
             video: {
@@ -137,9 +153,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)) {
@@ -155,9 +171,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 ?? '',
@@ -166,19 +182,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;
         }
@@ -203,12 +219,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,52 +234,52 @@ 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] ?? '';
+        const res = await this.vapixAgent.getParameter([paramName], options);
+        return 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 responseStringify(res));
+            throw new ErrorWithResponse(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 responseStringify(res));
+            throw new ErrorWithResponse(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] === '') {
@@ -274,10 +290,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 = {
@@ -291,7 +307,7 @@ const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, c
     if (!isFirmwareVersionAtLeast(firmWareVersion, FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
         return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
     }
-    if (bitrateMode === null) {
+    if (bitrateMode === undefined) {
         return '';
     }
     const data = {

package/esm/PlaneTrackerAPI.js

@@ -0,0 +1,243 @@
+import { z } from 'zod';
+import { paramToUrl } from './internal/utils';
+import { blackListSchema, cameraSettingsSchema, flightInfoSchema, getIcaoSchema, mapInfoSchema, priorityListSchema, serverSettingsSchema, trackingModeSchema, whiteListSchema, wsAliasResponseSchema, zonesSchema, } from './types/PlaneTrackerAPI';
+import { CannotSetCoordsInAutoModeError, ImportSettingsError, InvalidAltitudeError, InvalidLatLngError, ParsingBlobError, ResetCalibrationError, ServerError, BadRequestError, ErrorWithResponse, } from './errors/errors';
+import { ProxyClient } from './internal/ProxyClient';
+import { cameraListSchema } from './types/GenetecAgent';
+const BASE_PATH = '/local/planetracker';
+export class PlaneTrackerAPI {
+    client;
+    apiUser;
+    constructor(client, apiUser) {
+        this.client = client;
+        this.apiUser = apiUser;
+    }
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getWsEventsPath = () => `${BASE_PATH}/package/ws`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return z.boolean().parse(res.state);
+    }
+    async serverRunCheck(options) {
+        const agent = this.getClient(options?.proxyParams);
+        return await agent.get({ path: `${BASE_PATH}/package/serverRunCheck.cgi`, timeout: options?.timeout });
+    }
+    async getLiveViewAlias(rtspUrl, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: `${BASE_PATH}/getLiveViewAlias.cgi`,
+            parameters: { rtsp_url: rtspUrl },
+            timeout: options?.timeout,
+        });
+        return wsAliasResponseSchema.parse(await res.json());
+    }
+    async resetPtzCalibration(options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: `${BASE_PATH}/package/resetPtzCalibration.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            throw new ResetCalibrationError('PTZ', res);
+        }
+    }
+    async resetFocusCalibration(options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: `${BASE_PATH}/package/resetFocusCalibration.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            throw new ResetCalibrationError('FOCUS', res);
+        }
+    }
+    async fetchCameraSettings(options) {
+        const res = await this._getJson(`${BASE_PATH}/package_camera_settings.cgi`, { action: 'get' }, options);
+        return cameraSettingsSchema.parse(res);
+    }
+    async setCameraSettings(settings, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settings, {
+            action: 'set',
+        }, options);
+    }
+    async fetchServerSettings(options) {
+        const res = await this._getJson(`${BASE_PATH}/package_server_settings.cgi`, { action: 'get' }, options);
+        return serverSettingsSchema.parse(res);
+    }
+    async exportAppSettings(dataType, options) {
+        return await this._getBlob(`${BASE_PATH}/package_data.cgi`, { action: 'EXPORT', dataType }, options);
+    }
+    async importAppSettings(dataType, formData, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path: `${BASE_PATH}/package_data.cgi`,
+            data: formData,
+            parameters: { action: 'IMPORT', dataType },
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            throw new ImportSettingsError(res);
+        }
+    }
+    async fetchFlightInfo(icao, options) {
+        const res = await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao }, options);
+        return flightInfoSchema.parse(res);
+    }
+    async getTrackingMode(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getTrackingMode.cgi`, undefined, options);
+        return trackingModeSchema.parse(res);
+    }
+    async setTrackingMode(mode, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, { mode }, this.apiUser, options);
+    }
+    async startTrackingPlane(icao, options) {
+        const agent = this.getClient(options?.proxyParams);
+        await agent.get({
+            path: `${BASE_PATH}/package/trackIcao.cgi`,
+            parameters: { icao, ...this.apiUser },
+            timeout: options?.timeout,
+        });
+    }
+    async stopTrackingPlane(options) {
+        const agent = this.getClient(options?.proxyParams);
+        await agent.get({
+            path: `${BASE_PATH}/package/resetIcao.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
+    }
+    async getIcao(by, value, options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getIcao.cgi`, { [by]: value }, options);
+        return getIcaoSchema.parse(res).icao;
+    }
+    async getPriorityList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);
+        return priorityListSchema.parse(res).priorityList;
+    }
+    async setPriorityList(priorityList, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, { priorityList }, this.apiUser, options);
+    }
+    async getWhiteList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
+        return whiteListSchema.parse(res).whiteList;
+    }
+    async setWhiteList(whiteList, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, { whiteList }, this.apiUser, options);
+    }
+    async getBlackList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getBlackList.cgi`, undefined, options);
+        return blackListSchema.parse(res).blackList;
+    }
+    async setBlackList(blackList, options) {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, { blackList }, this.apiUser, options);
+    }
+    async fetchMapInfo(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getMapInfo.cgi`, undefined, options);
+        return mapInfoSchema.parse(res);
+    }
+    async getZones(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getZones.cgi`, undefined, options);
+        return zonesSchema.parse(res);
+    }
+    async setZones(zones, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, zones, this.apiUser, options);
+    }
+    async goToCoordinates(lat, lon, alt, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: `${BASE_PATH}/package/goToCoordinates.cgi`,
+            parameters: { lat, lon, alt, ...this.apiUser },
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            if (res.status === 400 && res.statusText === 'Cannot set coordinates in automatic mode') {
+                throw new CannotSetCoordsInAutoModeError();
+            }
+            if (res.status === 400 && res.statusText === 'Invalid lat/lon parameters') {
+                throw new InvalidLatLngError();
+            }
+            if (res.status === 400 && res.statusText === 'Invalid alt parameter') {
+                throw new InvalidAltitudeError();
+            }
+            if (res.status === 400) {
+                throw new BadRequestError(res);
+            }
+            if (res.status === 500) {
+                throw new ServerError();
+            }
+        }
+    }
+    async checkGenetecConnection(params, options) {
+        return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, params, options);
+    }
+    async getGenetecCameraList(params, options) {
+        const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, params, options);
+        return cameraListSchema.parse(await res.json());
+    }
+    async _getJson(path, parameters, options, headers) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout, headers });
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new ErrorWithResponse(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 ErrorWithResponse(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 jsonData = JSON.stringify(data);
+        const res = await agent.post({
+            path,
+            data: jsonData,
+            parameters,
+            headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
+            timeout: options?.timeout,
+        });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new ErrorWithResponse(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 ErrorWithResponse(res);
+        }
+    }
+}