camstreamerlib 4.0.0-beta.7 → 4.0.0-beta.70

package/cjs/CamSwitcherAPI.js

@@ -3,14 +3,14 @@ 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;
@@ -18,111 +18,127 @@ class CamSwitcherAPI {
     constructor(client, CustomFormData = FormData) {
         this.client = client;
         this.CustomFormData = CustomFormData;
-        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.vapixAgent = new VapixAPI_1.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_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`, 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 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) {
+    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 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: {
@@ -140,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)) {
@@ -158,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 ?? '',
@@ -169,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 {
@@ -206,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;
@@ -221,52 +237,52 @@ 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,
             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 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 errors_1.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 (0, common_1.responseStringify)(res));
+            throw new errors_1.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] === '') {
@@ -277,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;
@@ -295,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/PlaneTrackerAPI.d.ts

@@ -0,0 +1,233 @@
+import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
+import { ICAO, TApiUser, TBlackList, TCameraSettings, TExportDataType, TGetIcaoByOption, TImportDataType, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
+import { THttpRequestOptions, TProxyParams } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
+    private client;
+    private apiUser;
+    constructor(client: Client, apiUser: TApiUser);
+    static getProxyPath: () => string;
+    static getWsEventsPath: () => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    serverRunCheck(options?: THttpRequestOptions): Promise<TResponse>;
+    getLiveViewAlias(rtspUrl: string, options?: THttpRequestOptions): Promise<{
+        ws: string;
+        ws_initial_message: string;
+        alias: string;
+    }>;
+    resetPtzCalibration(options?: THttpRequestOptions): Promise<void>;
+    resetFocusCalibration(options?: THttpRequestOptions): Promise<void>;
+    fetchCameraSettings(options?: THttpRequestOptions): Promise<{
+        camera: {
+            ip: string;
+            port: number;
+            protocol: "https" | "http" | "https_insecure";
+            user: string;
+            pass: string;
+        };
+        units: "metric" | "imperial";
+        adsbSource: {
+            ip: string;
+            port: number;
+        };
+        cameraCalibrationProcessConfig: {
+            nightSkyCalibrationEnabled: boolean;
+            scheduleNightSkyCalibrationTimestamp: number;
+            focusCalibrationPoints: string;
+        };
+        cameraConfig: {
+            defaultCaptureSizeMeters: number;
+            captureSizeExtensionMeters: number;
+            maxZoomLevel?: number | undefined;
+        };
+        stream: {
+            width: number;
+            height: number;
+        };
+        imageConfig: {
+            dayAperture: number;
+            nightAperture: number;
+            maxGain: number;
+        };
+        airportConfig: {
+            icao: string;
+            centerLat: number;
+            centerLon: number;
+            radius: number;
+        };
+        trackingConfig: {
+            prioritizeEmergency: boolean;
+            trackingZoneWeightIncrease: number;
+            guardTourEnabled: boolean;
+            guardTourId: number;
+        };
+        widget: {
+            enabled: boolean;
+            scale: number;
+            coord: "top_left" | "top_right" | "bottom_left" | "bottom_right";
+            posX: number;
+            posY: number;
+        };
+        airportWidget: {
+            enabled: boolean;
+            scale: number;
+            coord: "top_left" | "top_right" | "bottom_left" | "bottom_right";
+            posX: number;
+            posY: number;
+        };
+        fr24FlightInfoSource: {
+            enabled: boolean;
+            priority: number;
+            apiToken: string;
+            validateFlights: boolean;
+        };
+        radarcapeFlightInfoSource: {
+            ip: string;
+            port: number;
+            enabled: boolean;
+            priority: number;
+        };
+        identificationLabel: {
+            firstRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+            secondRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+            thirdRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+            fourthRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+            opacity: number;
+        };
+        acs: {
+            ip: string;
+            port: number;
+            enabled: boolean;
+            protocol: "https" | "http" | "https_insecure";
+            user: string;
+            pass: string;
+            sourceKey: string;
+        };
+        genetec: {
+            ip: string;
+            port: number;
+            enabled: boolean;
+            cameraList: string[];
+            appId: string;
+            protocol: "https" | "http" | "https_insecure";
+            user: string;
+            pass: string;
+            baseUri: string;
+        };
+        overlayText?: {
+            displayIcao?: boolean | undefined;
+            displayRegistration?: boolean | undefined;
+            displayFlightNumber?: boolean | undefined;
+            displayAltitude?: boolean | undefined;
+            displayVelocity?: boolean | undefined;
+            displayDistance?: boolean | undefined;
+            displayFOV?: boolean | undefined;
+            displayPTError?: boolean | undefined;
+            displayPTZSpeed?: boolean | undefined;
+            displayVelocityData?: boolean | undefined;
+            displaySignalQuality?: boolean | undefined;
+            displayAutoTrackingInfo?: boolean | undefined;
+            displayGPSCoords?: boolean | undefined;
+            displayVapixQuery?: boolean | undefined;
+            displayFocus?: boolean | undefined;
+            displayAperture?: boolean | undefined;
+            displaySunDistance?: boolean | undefined;
+            displayTickTime?: boolean | undefined;
+            displayAircraftInfo?: boolean | undefined;
+        } | undefined;
+    }>;
+    setCameraSettings(settings: TCameraSettings, options?: THttpRequestOptions): Promise<TResponse>;
+    fetchServerSettings(options?: THttpRequestOptions): Promise<{
+        cameraCalibration: {
+            posLat: number;
+            posLon: number;
+            geoidHN: number;
+            altitudeAmsl: number;
+            rotationEast: number;
+            rotationNorth: number;
+            rotationUp: number;
+            tiltTransformationCoefA: number;
+            tiltCameraKnownPoint: number;
+            tiltRealKnownPoint: number;
+            panErrorCorrection: {
+                cameraPan: number;
+                realPan: number;
+            }[];
+        };
+    }>;
+    exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
+    importAppSettings(dataType: TImportDataType, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
+    fetchFlightInfo(icao: ICAO, options?: THttpRequestOptions): Promise<{
+        destinationAirport: {
+            icao?: string | undefined;
+            iata?: string | undefined;
+            city?: string | undefined;
+        };
+        registration?: string | undefined;
+        callsign?: string | undefined;
+        flightNumber?: string | undefined;
+        aircraftType?: string | undefined;
+        airlines?: string | undefined;
+        originAirport?: {
+            icao?: string | undefined;
+            iata?: string | undefined;
+            city?: string | undefined;
+        } | undefined;
+        flightImages?: {
+            src?: string | undefined;
+            photographer?: string | undefined;
+        }[] | undefined;
+    }>;
+    getTrackingMode(options?: THttpRequestOptions): Promise<{
+        mode: "MANUAL" | "AUTOMATIC";
+    }>;
+    setTrackingMode(mode: TTrackingMode['mode'], options?: THttpRequestOptions): Promise<void>;
+    startTrackingPlane(icao: ICAO, options?: THttpRequestOptions): Promise<void>;
+    stopTrackingPlane(options?: THttpRequestOptions): Promise<void>;
+    getIcao(by: TGetIcaoByOption, value: string, options?: THttpRequestOptions): Promise<string>;
+    getPriorityList(options?: THttpRequestOptions): Promise<string[]>;
+    setPriorityList(priorityList: TPriorityList['priorityList'], options?: THttpRequestOptions): Promise<TResponse>;
+    getWhiteList(options?: THttpRequestOptions): Promise<string[]>;
+    setWhiteList(whiteList: TWhiteList['whiteList'], options?: THttpRequestOptions): Promise<TResponse>;
+    getBlackList(options?: THttpRequestOptions): Promise<string[]>;
+    setBlackList(blackList: TBlackList['blackList'], options?: THttpRequestOptions): Promise<TResponse>;
+    fetchMapInfo(options?: THttpRequestOptions): Promise<{
+        minZoom: number;
+        maxZoom: number;
+        mapTypes: ("roadmap" | "satellite")[];
+        tileSize: number;
+    }>;
+    getZones(options?: THttpRequestOptions): Promise<{
+        zones: {
+            enabled: boolean;
+            area: [{
+                lat: number;
+                lon: number;
+            }, ...{
+                lat: number;
+                lon: number;
+            }[]];
+            flightDirection: "all" | "arrival" | "departure";
+            weight: number;
+            name?: string | undefined;
+            minAltitudeAmsl?: number | undefined;
+            maxAltitudeAmsl?: number | undefined;
+            minSpeedKmph?: number | undefined;
+            maxSpeedKmph?: number | undefined;
+        }[];
+    }>;
+    setZones(zones: TZones, options?: THttpRequestOptions): Promise<void>;
+    goToCoordinates(lat: number, lon: number, alt?: number, options?: THttpRequestOptions): Promise<void>;
+    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<TResponse>;
+    getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<{
+        value: string;
+        index: number;
+        label: string;
+    }[]>;
+    private _getJson;
+    private _getBlob;
+    private parseBlobResponse;
+    private _postJsonEncoded;
+    private _postUrlEncoded;
+}