camstreamerlib 4.0.0-beta.62 → 4.0.0-beta.64

package/cjs/CamOverlayAPI.js

@@ -83,7 +83,7 @@ class CamOverlayAPI {
             throw new errors_1.ServiceNotFoundError();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async getSingleService(serviceId, options) {
@@ -165,7 +165,7 @@ class CamOverlayAPI {
             timeout: options?.timeout,
         });
         if (!res.ok) {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async _getJson(path, parameters, options) {
@@ -175,7 +175,7 @@ class CamOverlayAPI {
             return await res.json();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async _post(path, data, parameters, options, headers) {
@@ -185,7 +185,7 @@ class CamOverlayAPI {
             return await res.json();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async _getBlob(path, parameters, options) {
@@ -195,7 +195,7 @@ class CamOverlayAPI {
             return await this.parseBlobResponse(res);
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async parseBlobResponse(response) {

package/cjs/CamScripterAPI.d.ts

@@ -0,0 +1,46 @@
+import { ProxyClient } from './internal/ProxyClient';
+import { IClient, TResponse } from './internal/types';
+import { THttpRequestOptions, TProxyParams, TStorageType } from './types/common';
+export declare class CamScripterAPI<Client extends IClient<TResponse, any>> {
+    private client;
+    constructor(client: Client);
+    static getProxyPath: () => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<{
+        name: string;
+        ip: string;
+    }[]>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<[{
+        type: "FLASH";
+        capacity_mb: number;
+    }, {
+        type: "SD_DISK";
+        capacity_mb: number;
+    }] | [{
+        type: "FLASH";
+        capacity_mb: number;
+    }]>;
+    getPackageList(options?: THttpRequestOptions): Promise<{
+        storage: "FLASH" | "SD_DISK";
+        manifest: {
+            package_name: string;
+            package_menu_name: string;
+            package_version: string;
+            vendor: string;
+            ui_link: string;
+            required_camscripter_version?: string | undefined;
+            required_camscripter_rbi_version?: string | undefined;
+        };
+    }[]>;
+    installPackages(formData: Parameters<Client['post']>[0]['data'], storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
+    uninstallPackage(packageId: string, options?: THttpRequestOptions): Promise<void>;
+    importSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
+    exportSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
+    getNodejsStatus(options?: THttpRequestOptions): Promise<{
+        node_state: "OK" | "NOT_INSTALLED" | "NOT_FOUND";
+    }>;
+    installNodejs(storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
+    private _getJson;
+    private _post;
+}

package/cjs/CamScripterAPI.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamScripterAPI = void 0;
 const errors_1 = require("./errors/errors");
 const ProxyClient_1 = require("./internal/ProxyClient");
-const utils_1 = require("./internal/utils");
 const CamScripterAPI_1 = require("./types/CamScripterAPI");
 const common_1 = require("./types/common");
 const BASE_PATH = '/local/camscripter';
@@ -64,7 +63,7 @@ class CamScripterAPI {
             return await res.json();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async _post(path, data, parameters, options, headers) {
@@ -74,7 +73,7 @@ class CamScripterAPI {
             return await res.json();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
 }

package/cjs/CamStreamerAPI.d.ts

@@ -0,0 +1,64 @@
+import { ProxyClient } from './internal/ProxyClient';
+import { IClient, TResponse } from './internal/types';
+import { TCameraStream, TStream } from './types/CamStreamerAPI';
+import { THttpRequestOptions, TProxyParams } from './types/common';
+export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
+    private client;
+    constructor(client: Client);
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getUtcTime(options?: THttpRequestOptions): Promise<number>;
+    getStreamList(options?: THttpRequestOptions): Promise<Record<number, {
+        enabled: 0 | 1;
+        schedule: string;
+        active: 0 | 1;
+        audioSource: string;
+        avSyncMsec: number;
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        outputParameters: string;
+        outputType: "video" | "none" | "images";
+        mediaServerUrl: string;
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        inputUrl: string;
+        forceStereo: 0 | 1;
+        streamDelay: number | null;
+        statusLed: number;
+        statusPort: string;
+        callApi: number;
+        trigger: string;
+        prepareAhead: number;
+        startTime: number | null;
+        stopTime: number | null;
+    }>>;
+    getStream(streamId: number, options?: THttpRequestOptions): Promise<{
+        enabled: 0 | 1;
+        schedule: string;
+        active: 0 | 1;
+        audioSource: string;
+        avSyncMsec: number;
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        outputParameters: string;
+        outputType: "video" | "none" | "images";
+        mediaServerUrl: string;
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        inputUrl: string;
+        forceStereo: 0 | 1;
+        streamDelay: number | null;
+        statusLed: number;
+        statusPort: string;
+        callApi: number;
+        trigger: string;
+        prepareAhead: number;
+        startTime: number | null;
+        stopTime: number | null;
+    }>;
+    getStreamParameter(streamId: number, paramName: string, options?: THttpRequestOptions): Promise<string>;
+    setStream(streamId: number, params: Partial<TStream>, options?: THttpRequestOptions): Promise<void>;
+    setStreamParameter(streamId: number, paramName: string, value: string, options?: THttpRequestOptions): Promise<void>;
+    isStreaming(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
+    deleteStream(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
+    private _getJson;
+}
+export declare const parseCameraStreamResponse: (cameraStreamData: TCameraStream) => TStream;

package/cjs/CamStreamerAPI.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCameraStreamResponse = exports.CamStreamerAPI = void 0;
 const zod_1 = require("zod");
 const ProxyClient_1 = require("./internal/ProxyClient");
-const utils_1 = require("./internal/utils");
 const CamStreamerAPI_1 = require("./types/CamStreamerAPI");
 const errors_1 = require("./errors/errors");
 const BASE_PATH = '/local/camstreamer';
@@ -76,7 +75,7 @@ class CamStreamerAPI {
             return await res.json();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
 }

package/cjs/CamSwitcherAPI.d.ts

@@ -0,0 +1,167 @@
+import { IClient, TResponse } from './internal/types';
+import { TStreamSaveList, TTrackerSaveList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
+import { TAudioChannel, THttpRequestOptions, TProxyParams, TStorageType } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
+    private client;
+    private CustomFormData;
+    private vapixAgent;
+    constructor(client: Client, CustomFormData?: {
+        new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
+        prototype: FormData;
+    });
+    static getProxyPath: () => string;
+    static getWsEventsPath: () => string;
+    static getClipPreviewPath: (clipId: string, storage: TStorageType) => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<{
+        name: string;
+        ip: string;
+    }[]>;
+    generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
+    getMaxFps(source: number, options?: THttpRequestOptions): Promise<number>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<{
+        storage: "FLASH" | "SD_DISK";
+        writable: boolean;
+        size: number;
+        available: number;
+    }[]>;
+    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getOutputInfo(options?: THttpRequestOptions): Promise<{
+        rtspUrl: string;
+        ws: string;
+        wsInitialMessage: string;
+    }>;
+    getAudioPushInfo(options?: THttpRequestOptions): Promise<{
+        ws: string;
+        wsInitialMessage: string;
+    }>;
+    getStreamSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        ip?: string | undefined;
+        niceName?: string | undefined;
+        mdnsName?: string | undefined;
+        port?: number | undefined;
+        enabled?: boolean | undefined;
+        auth?: string | undefined;
+        query?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        viewNumber?: number | undefined;
+    }>>;
+    getClipSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        niceName?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+    }>>;
+    getPlaylistSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        niceName?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        isFavourite?: boolean | undefined;
+        sortIndexFavourite?: number | undefined;
+        play_type?: "PLAY_ALL" | "PLAY_ALL_LOOP" | "PLAY_ALL_SHUFFLED" | "PLAY_ALL_LOOP_SHUFFLED" | "PLAY_ONE_RANDOM" | undefined;
+        default?: boolean | undefined;
+        stream_list?: {
+            repeat: number;
+            video: {
+                storage?: "FLASH" | "SD_DISK" | undefined;
+                stream_name?: string | undefined;
+                clip_name?: string | undefined;
+                tracker_name?: string | undefined;
+            };
+            id: string;
+            isTimeoutCustom: boolean;
+            ptz_preset_pos_name: string;
+            timeout: number;
+            audio?: {
+                storage?: "FLASH" | "SD_DISK" | undefined;
+                stream_name?: string | undefined;
+                clip_name?: string | undefined;
+                tracker_name?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+    }>>;
+    getTrackerSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        name?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        viewNumber?: number | undefined;
+        id?: string | undefined;
+        previewId?: string | undefined;
+        duration?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        fps?: number | undefined;
+        motion_history_frames?: number | undefined;
+        include_zone?: number[][] | undefined;
+        include_node_ids?: string[] | undefined;
+        camera_list?: {
+            name: string;
+            id: string;
+            overview: boolean;
+            zone: number[];
+            playlist_name: string;
+            ptz_preset_pos_no: number;
+        }[] | undefined;
+        camera_view_number?: number | undefined;
+    }>>;
+    setStreamSaveList(data: TStreamSaveList, options?: THttpRequestOptions): Promise<void>;
+    setClipSaveList(data: TClipSaveList, options?: THttpRequestOptions): Promise<void>;
+    setPlaylistSaveList(data: TPlaylistSaveList, options?: THttpRequestOptions): Promise<void>;
+    setTrackerSaveList(data: TTrackerSaveList, options?: THttpRequestOptions): Promise<void>;
+    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, clipId: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
+    removeClip(clipId: string, storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
+    getClipList(options?: THttpRequestOptions): Promise<Record<string, {
+        storage: "FLASH" | "SD_DISK";
+        stream_list: ({
+            type: "video";
+            width: number;
+            height: number;
+            fps: number;
+            sample_rate: number;
+            h264_profile: "high" | "main" | "baseline";
+            h264_level: "4.1";
+            gop: number;
+            bitrate: number;
+        } | {
+            type: "audio";
+            sample_rate: number;
+            channel_count: 1 | 2;
+        })[];
+        duration: number;
+    }>>;
+    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<void>;
+    setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<void>;
+    setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<void>;
+    setDefaultPlaylist(playlistId: string, options?: THttpRequestOptions): Promise<void>;
+    setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<void>;
+    getCamSwitchOptions(options?: THttpRequestOptions): Promise<any>;
+    getGlobalAudioSettings(options?: THttpRequestOptions): Promise<{
+        type: "fromSource" | "source";
+        source: string;
+        storage?: string | undefined;
+    }>;
+    getSecondaryAudioSettings(options?: THttpRequestOptions): Promise<{
+        type: "CLIP" | "STREAM" | "NONE";
+        storage: "FLASH" | "SD_DISK";
+        secondaryAudioLevel: number;
+        masterAudioLevel: number;
+        streamName?: string | undefined;
+        clipName?: string | undefined;
+    }>;
+    getPermanentRtspUrlToken(options?: THttpRequestOptions): Promise<string>;
+    private _getJson;
+    private _post;
+    private setParamFromCameraJSON;
+    private getParamFromCameraAndJSONParse;
+}

package/cjs/CamSwitcherAPI.js

@@ -263,7 +263,7 @@ class CamSwitcherAPI {
             return await res.json();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async _post(path, data, parameters, options, headers) {
@@ -273,7 +273,7 @@ class CamSwitcherAPI {
             return await res.json();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     setParamFromCameraJSON(paramName, data, options) {

package/cjs/PlaneTrackerAPI.d.ts

@@ -0,0 +1,229 @@
+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;
+        };
+    }>;
+    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;
+}