camstreamerlib 4.0.0-beta.16 → 4.0.0-beta.161

package/cjs/PlaneTrackerAPI.d.ts

@@ -1,30 +1,239 @@
-import { IClient, TResponse } from './internal/types';
-type ICAO = string;
-export declare const BASE_URL = "/local/planetracker";
-export declare class PlaneTrackerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
-    private client;
-    constructor(client: Client);
-    static getProxyUrlPath: () => string;
-    checkCameraTime(): Promise<boolean>;
-    fetchCameraSettings: () => Promise<any>;
-    fetchServerSettings: () => Promise<any>;
-    fetchMapInfo: () => Promise<any>;
-    fetchFlightInfo: (icao: ICAO) => Promise<any>;
-    getZones: () => Promise<any>;
-    setZones: (zonesJsonString: string) => Promise<any>;
-    getPriorityList: () => Promise<any>;
-    setPriorityList: (priorityListJsonString: string) => Promise<any>;
-    getWhiteList: () => Promise<any>;
-    setWhiteList: (whiteListJsonString: string) => Promise<any>;
-    getBlackList: () => Promise<any>;
-    setBlackList: (blackListJsonString: string) => Promise<any>;
-    getTrackingMode: () => Promise<any>;
-    setTrackingMode: (modeJsonString: string) => Promise<any>;
-    startTrackingPlane: (icao: ICAO) => Promise<TResponse>;
-    stopTrackingPlane: () => Promise<TResponse>;
-    goToCoordinates: (lat: number, lon: number, alt?: number) => Promise<TResponse>;
-    private _get;
-    private _post;
-    private _postJsonEncoded;
+import { IClient, TParameters, TResponse } from './internal/types';
+import { ICAO, TApiUser, TBlackList, TCameraSettings, TExportDataType, TGetIcaoByOption, TImportDataType, TPriorityList, TTrackingMode, TTypePriorityList, TWhiteList, TZones } from './types/PlaneTrackerAPI';
+import { THttpRequestOptions } from './types/common';
+import { BasicAPI } from './internal/BasicAPI';
+export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> extends BasicAPI<Client> {
+    private apiUser;
+    constructor(client: Client, apiUser: TApiUser);
+    static getProxyPath: () => string;
+    static getWsEventsPath: () => string;
+    checkAPIAvailable(options?: THttpRequestOptions): Promise<void>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    serverRunCheck(options?: THttpRequestOptions): Promise<boolean>;
+    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;
+            pass: string;
+            user: string;
+            protocol: "https" | "http" | "https_insecure";
+        };
+        units: "metric" | "imperial";
+        trackingDomain: "adsb" | "dronetag";
+        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;
+            enabled: boolean;
+            port: number;
+            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;
+            enabled: boolean;
+            port: number;
+            pass: string;
+            user: string;
+            protocol: "https" | "http" | "https_insecure";
+            sourceKey: string;
+        };
+        genetec: {
+            ip: string;
+            enabled: boolean;
+            port: number;
+            cameraList: string[];
+            pass: string;
+            appId: string;
+            user: string;
+            protocol: "https" | "http" | "https_insecure";
+            baseUri: string;
+        };
+        camstreamerIntegration: {
+            adPlacementEnabled: boolean;
+            adMinIntervalSec: number;
+            adShortDurationSec: number;
+            adLongDurationSec: number;
+        };
+        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;
+            displayAdsbVelocityData?: boolean | undefined;
+            displaySignalQuality?: boolean | undefined;
+            displayAutoTrackingInfo?: boolean | undefined;
+            displayGPSCoords?: boolean | undefined;
+            displayVapixQuery?: boolean | undefined;
+            displayFocus?: boolean | undefined;
+            displayAperture?: boolean | undefined;
+            displayAircraftInfo?: boolean | undefined;
+            displaySunDistance?: boolean | undefined;
+            displayTickTime?: boolean | undefined;
+            displaySystemInfo?: boolean | undefined;
+        } | undefined;
+    }>;
+    setCameraSettings(settings: TCameraSettings, options?: THttpRequestOptions): Promise<void>;
+    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<ReturnType<Awaited<ReturnType<Client["get"]>>["blob"]>>;
+    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<void>;
+    getTypePriorityList(options?: THttpRequestOptions): Promise<string[]>;
+    setTypePriorityList(typePriorityList: TTypePriorityList['typePriorityList'], options?: THttpRequestOptions): Promise<void>;
+    getWhiteList(options?: THttpRequestOptions): Promise<string[]>;
+    setWhiteList(whiteList: TWhiteList['whiteList'], options?: THttpRequestOptions): Promise<void>;
+    getBlackList(options?: THttpRequestOptions): Promise<string[]>;
+    setBlackList(blackList: TBlackList['blackList'], options?: THttpRequestOptions): Promise<void>;
+    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>;
+    downloadReport(options?: THttpRequestOptions): Promise<string>;
+    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<boolean>;
+    getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<{
+        value: string;
+        label: string;
+        index: number;
+    }[]>;
 }
-export {};

package/cjs/PlaneTrackerAPI.js

@@ -1,113 +1,199 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlaneTrackerAPI = exports.BASE_URL = void 0;
+exports.PlaneTrackerAPI = void 0;
 const zod_1 = require("zod");
-const utils_1 = require("./internal/utils");
-exports.BASE_URL = '/local/planetracker';
-class PlaneTrackerAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    static getProxyUrlPath = () => `${exports.BASE_URL}/proxy.cgi`;
-    async checkCameraTime() {
-        const responseSchema = zod_1.z.discriminatedUnion('state', [
-            zod_1.z.object({
-                state: zod_1.z.literal(true),
-                code: zod_1.z.number(),
-            }),
-            zod_1.z.object({
-                state: zod_1.z.literal(false),
-                code: zod_1.z.number(),
-                reason: zod_1.z.union([
-                    zod_1.z.literal('INVALID_TIME'),
-                    zod_1.z.literal('COULDNT_RESOLVE_HOST'),
-                    zod_1.z.literal('CONNECTION_ERROR'),
-                ]),
-                message: zod_1.z.string(),
-            }),
-        ]);
-        const response = await this._get(`${exports.BASE_URL}/camera_time.cgi`);
-        const cameraTime = responseSchema.parse(response);
-        if (!cameraTime.state) {
-            console.error(`Camera time check failed: ${cameraTime.reason} - ${cameraTime.message}`);
-        }
-        return cameraTime.state;
-    }
-    fetchCameraSettings = async () => {
-        return await this._get(`${exports.BASE_URL}/package_camera_settings.cgi?action=get`);
-    };
-    fetchServerSettings = async () => {
-        return await this._get(`${exports.BASE_URL}/package_server_settings.cgi?action=get`);
-    };
-    fetchMapInfo = async () => {
-        return await this._get(`${exports.BASE_URL}/package/getMapInfo.cgi`);
-    };
-    fetchFlightInfo = async (icao) => {
-        return await this._get(`${exports.BASE_URL}/package/flightInfo.cgi?icao=${icao}`);
-    };
-    getZones = async () => {
-        return await this._get(`${exports.BASE_URL}/package/getZones.cgi`);
-    };
-    setZones = async (zonesJsonString) => {
-        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setZones.cgi`, zonesJsonString);
-    };
-    getPriorityList = async () => {
-        return await this._get(`${exports.BASE_URL}/package/getPriorityList.cgi`);
-    };
-    setPriorityList = async (priorityListJsonString) => {
-        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setPriorityList.cgi`, priorityListJsonString);
-    };
-    getWhiteList = async () => {
-        return await this._get(`${exports.BASE_URL}/package/getWhiteList.cgi`);
-    };
-    setWhiteList = async (whiteListJsonString) => {
-        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setWhiteList.cgi`, whiteListJsonString);
-    };
-    getBlackList = async () => {
-        return await this._get(`${exports.BASE_URL}/package/getBlackList.cgi`);
-    };
-    setBlackList = async (blackListJsonString) => {
-        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setBlackList.cgi`, blackListJsonString);
-    };
-    getTrackingMode = async () => {
-        return await this._get(`${exports.BASE_URL}/package/getTrackingMode.cgi`);
-    };
-    setTrackingMode = async (modeJsonString) => {
-        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setTrackingMode.cgi`, modeJsonString);
-    };
-    startTrackingPlane = async (icao) => {
-        return await this.client.get(`${exports.BASE_URL}/package/trackIcao.cgi?icao=${icao}`);
-    };
-    stopTrackingPlane = async () => {
-        return await this.client.get(`${exports.BASE_URL}/package/resetIcao.cgi`);
-    };
-    goToCoordinates = async (lat, lon, alt) => {
-        const url = `${exports.BASE_URL}/package/goToCoordinates.cgi?lat=${lat}&lon=${lon}`;
-        return await this.client.get(`${url}${alt !== undefined ? `&alt=${alt}` : ''}`);
-    };
-    async _get(...args) {
-        const res = await this.client.get(...args);
-        if (res.ok) {
-            return (await res.json());
+const PlaneTrackerAPI_1 = require("./types/PlaneTrackerAPI");
+const errors_1 = require("./errors/errors");
+const GenetecAgent_1 = require("./types/GenetecAgent");
+const BasicAPI_1 = require("./internal/BasicAPI");
+const BASE_PATH = '/local/planetracker';
+class PlaneTrackerAPI extends BasicAPI_1.BasicAPI {
+    apiUser;
+    constructor(client, apiUser) {
+        super(client);
+        this.apiUser = apiUser;
+    }
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getWsEventsPath = () => `${BASE_PATH}/package/ws`;
+    async checkAPIAvailable(options) {
+        await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
+    }
+    async checkCameraTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return zod_1.z.boolean().parse(res.state);
+    }
+    async serverRunCheck(options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: `${BASE_PATH}/package/serverRunCheck.cgi`,
+            timeout: options?.timeout,
+        });
+        return res.status === 200;
+    }
+    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 PlaneTrackerAPI_1.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 errors_1.ResetCalibrationError('PTZ', res);
         }
-        else {
-            throw new Error(await (0, utils_1.responseStringify)(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 errors_1.ResetCalibrationError('FOCUS', res);
         }
     }
-    async _post(...args) {
-        const res = await this.client.post(...args);
-        if (res.ok) {
-            return (await res.json());
+    async fetchCameraSettings(options) {
+        const res = await this._getJson(`${BASE_PATH}/package_camera_settings.cgi`, { action: 'get' }, options);
+        return PlaneTrackerAPI_1.cameraSettingsSchema.parse(res);
+    }
+    async setCameraSettings(settings, options) {
+        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 PlaneTrackerAPI_1.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 errors_1.ImportSettingsError(res);
         }
-        else {
-            throw new Error(await (0, utils_1.responseStringify)(res));
+    }
+    async fetchFlightInfo(icao, options) {
+        const res = await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao }, options);
+        return PlaneTrackerAPI_1.flightInfoSchema.parse(res);
+    }
+    async getTrackingMode(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getTrackingMode.cgi`, undefined, options);
+        return PlaneTrackerAPI_1.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 PlaneTrackerAPI_1.getIcaoSchema.parse(res).icao;
+    }
+    async getPriorityList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);
+        return PlaneTrackerAPI_1.priorityListSchema.parse(res).priorityList;
+    }
+    async setPriorityList(priorityList, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, { priorityList }, this.apiUser, options);
+    }
+    async getTypePriorityList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getTypePriorityList.cgi`, undefined, options);
+        return PlaneTrackerAPI_1.typePriorityListSchema.parse(res).typePriorityList;
+    }
+    async setTypePriorityList(typePriorityList, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/package/setTypePriorityList.cgi`, { typePriorityList }, this.apiUser, options);
+    }
+    async getWhiteList(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
+        return PlaneTrackerAPI_1.whiteListSchema.parse(res).whiteList;
+    }
+    async setWhiteList(whiteList, options) {
+        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 PlaneTrackerAPI_1.blackListSchema.parse(res).blackList;
+    }
+    async setBlackList(blackList, options) {
+        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 PlaneTrackerAPI_1.mapInfoSchema.parse(res);
+    }
+    async getZones(options) {
+        const res = await this._getJson(`${BASE_PATH}/package/getZones.cgi`, undefined, options);
+        return PlaneTrackerAPI_1.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 errors_1.CannotSetCoordsInAutoModeError();
+            }
+            if (res.status === 400 && res.statusText === 'Invalid lat/lon parameters') {
+                throw new errors_1.InvalidLatLngError();
+            }
+            if (res.status === 400 && res.statusText === 'Invalid alt parameter') {
+                throw new errors_1.InvalidAltitudeError();
+            }
+            if (res.status === 400) {
+                throw new errors_1.BadRequestError(res);
+            }
+            if (res.status === 500) {
+                throw new errors_1.ServerError();
+            }
         }
     }
-    async _postJsonEncoded(...args) {
-        const [path, data, params, headers] = args;
-        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        return this._post(path, data, params, { ...baseHeaders, ...headers });
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
+    }
+    async checkGenetecConnection(params, options) {
+        const res = await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, params, options);
+        return res.status === 200;
+    }
+    async getGenetecCameraList(params, options) {
+        const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, params, options);
+        return GenetecAgent_1.cameraListSchema.parse(await res.json());
     }
 }
 exports.PlaneTrackerAPI = PlaneTrackerAPI;