camstreamerlib 4.0.0-beta.99 → 4.0.1

package/esm/CamScripterAPI.js

@@ -1,20 +1,16 @@
-import { ErrorWithResponse } from './errors/errors';
-import { ProxyClient } from './internal/ProxyClient';
-import { cameraTimeResponseSchema, nodeStateSchema, packageInfoListSchema, cameraStorageSchema, } from './types/CamScripterAPI';
+import z from 'zod';
+import { BasicAPI } from './internal/BasicAPI';
+import { nodeStateSchema, packageInfoListSchema, cameraStorageSchema } from './types/CamScripterAPI';
 import { networkCameraListSchema } from './types/common';
 const BASE_PATH = '/local/camscripter';
-export class CamScripterAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
+export class CamScripterAPI extends BasicAPI {
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    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 cameraTimeResponseSchema.parse(res).state;
+        return z.boolean().parse(res.state);
     }
     async getNetworkCameraList(options) {
         const res = await this._getJson(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
@@ -53,24 +49,7 @@ export class CamScripterAPI {
     async installNodejs(storage, options) {
         await this._getJson(`${BASE_PATH}/node_update.cgi`, { storage: storage }, options);
     }
-    async _getJson(path, parameters, options) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ path, parameters, timeout: options?.timeout });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
-    }
-    async _post(path, data, parameters, options, headers) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
 }

package/esm/CamStreamerAPI.js

@@ -1,18 +1,19 @@
 import { z } from 'zod';
-import { ProxyClient } from './internal/ProxyClient';
-import { audioFileListSchema, storageListSchema, streamSchema, } from './types/CamStreamerAPI/CamStreamerAPI';
-import { ErrorWithResponse, UtcTimeFetchError, WsAuthorizationError, MigrationError, ParsingBlobError, } from './errors/errors';
+import { audioFileListSchema, diagnosticsSchema, srtStreamStatisticsSchema, storageListSchema, streamSchema, streamStatsSchema, } from './types/CamStreamerAPI/CamStreamerAPI';
+import { UtcTimeFetchError, WsAuthorizationError, MigrationError } from './errors/errors';
 import { oldStringStreamSchema, oldStringStreamSchemaWithId, } from './types/CamStreamerAPI/oldStreamSchema';
-import { paramToUrl } from './internal/utils';
+import { BasicAPI } from './internal/BasicAPI';
+import { streamPlatforms } from './types/CamStreamerAPI';
 const BASE_PATH = '/local/camstreamer';
-export class CamStreamerAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
+export class CamStreamerAPI extends BasicAPI {
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    static getWsEventsPath = () => `${BASE_PATH}/events`;
+    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 z.boolean().parse(res.data?.state);
     }
     async wsAuthorization(options) {
         const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
@@ -28,19 +29,35 @@ export class CamStreamerAPI {
         }
         return z.number().parse(res.data);
     }
+    async getMaxFps(source = 0, options) {
+        return await this._getJson(`${BASE_PATH}/get_max_framerate.cgi`, { video_source: source.toString() }, options);
+    }
+    async isCSPassValid(pass, options) {
+        const res = await this._getJson(`${BASE_PATH}/check_pass.cgi`, { pass }, options);
+        return res.data === '1';
+    }
+    async getCamStreamerAppLog(options) {
+        return await this._getText(`${BASE_PATH}/view_log.cgi`, undefined, options);
+    }
     async getStreamList(options) {
         const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get' }, options);
         const oldStreamListRecord = z.record(z.string(), oldStringStreamSchema).safeParse(res.data);
         if (oldStreamListRecord.success) {
-            const data = Object.entries(oldStreamListRecord.data).map(([id, streamData]) => ({
-                id: parseInt(id),
+            const data = Object.entries(oldStreamListRecord.data).map(([streamId, streamData]) => ({
+                streamId,
                 ...parseCameraStreamResponse(streamData),
             }));
-            throw new MigrationError([], data);
+            throw new MigrationError([], data, [], []);
         }
         const newStreamData = [];
+        const unknownStreamData = [];
         const oldStreamData = [];
+        const invalidStreamData = [];
         for (const streamData of res.data.streamList) {
+            if (streamData.platform !== undefined && !Object.values(streamPlatforms).includes(streamData.platform)) {
+                unknownStreamData.push(streamData);
+                continue;
+            }
             const newStreamParse = streamSchema.safeParse(streamData);
             if (newStreamParse.success) {
                 newStreamData.push(newStreamParse.data);
@@ -49,20 +66,20 @@ export class CamStreamerAPI {
             const oldStreamParse = oldStringStreamSchemaWithId.safeParse(streamData);
             if (oldStreamParse.success) {
                 oldStreamData.push({
-                    id: parseInt(oldStreamParse.data.id),
+                    streamId: oldStreamParse.data.streamId,
                     ...parseCameraStreamResponse(oldStreamParse.data),
                 });
                 continue;
             }
-            throw new Error('Failed to parse some stream entries');
+            invalidStreamData.push(streamData);
         }
-        if (oldStreamData.length > 0) {
-            throw new MigrationError(newStreamData, oldStreamData);
+        if (oldStreamData.length > 0 || invalidStreamData.length > 0) {
+            throw new MigrationError(newStreamData, oldStreamData, invalidStreamData, unknownStreamData);
         }
-        return newStreamData;
+        return [...newStreamData, ...unknownStreamData];
     }
     async setStreamList(streamList, options) {
-        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify({ streamList }), {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, { streamList }, {
             action: 'set',
         }, options);
     }
@@ -73,17 +90,30 @@ export class CamStreamerAPI {
             return newStream.data;
         }
         const oldStream = oldStringStreamSchema.passthrough().parse(res.data);
-        throw new MigrationError([], [{ id: streamId, ...parseCameraStreamResponse(oldStream) }]);
+        throw new MigrationError([], [{ streamId, ...parseCameraStreamResponse(oldStream) }], [], []);
     }
     async setStream(streamId, streamData, options) {
-        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify(streamData), {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, streamData, {
             action: 'set',
             stream_id: streamId,
         }, options);
     }
-    async isStreaming(streamId, options) {
+    async getStreamNetworkStatistics(streamId, options) {
         const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);
-        return res.data.is_streaming === 1;
+        return streamStatsSchema.parse(res.data);
+    }
+    async getSrtStreamStatistics(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/srt_statistics.cgi`, { stream_id: streamId }, options);
+        return srtStreamStatisticsSchema.parse(res.data);
+    }
+    async setStreamEnabled(streamId, enabled, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/set_stream_enabled.cgi`, { stream_id: streamId, enabled: enabled ? 1 : 0 }, options);
+    }
+    async setStreamActive(streamId, active, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/set_stream_active.cgi`, { stream_id: streamId, active: active ? 1 : 0 }, options);
+    }
+    async deleteStream(streamId, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/remove.cgi`, { stream_id: streamId }, options);
     }
     async listFiles(options) {
         const res = await this._getJson(`${BASE_PATH}/upload_audio.cgi`, { action: 'list' }, options);
@@ -96,7 +126,7 @@ export class CamStreamerAPI {
         }, options);
     }
     async removeFile(fileParams, options) {
-        await this._postUrlEncoded(`${BASE_PATH}/upload_audio.cgi`, { action: 'remove', ...fileParams }, options, undefined);
+        await this._postUrlEncoded(`${BASE_PATH}/upload_audio.cgi`, { action: 'remove', ...fileParams }, options);
     }
     async getFileStorage(options) {
         const res = await this._getJson(`${BASE_PATH}/upload_audio.cgi`, { action: 'get_storage' }, options);
@@ -105,59 +135,21 @@ export class CamStreamerAPI {
     async getFileFromCamera(path, options) {
         return await this._getBlob(`${BASE_PATH}/audio.cgi`, { path }, options);
     }
-    async _getJson(path, parameters, options) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ path, parameters, timeout: options?.timeout });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new 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 _postUrlEncoded(path, parameters, options, headers) {
-        const data = paramToUrl(parameters);
-        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
-        return this._post(path, data, undefined, options, { ...baseHeaders, ...headers });
-    }
-    async _postJsonEncoded(path, data, parameters, options, headers) {
-        const agent = this.getClient(options?.proxyParams);
-        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        return agent.post({
-            path,
-            data,
-            parameters,
-            timeout: options?.timeout,
-            headers: { ...baseHeaders, ...headers },
-        });
-    }
-    async _post(path, data, parameters, options, headers) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
+    }
+    async getDiagnostics(params, options) {
+        const convertedParams = {
+            camerainfo: params.camerainfo ? '1' : '0',
+            checkserver: params.checkserver ? '1' : '0',
+            checkservertime: params.checkservertime ? '1' : '0',
+            speedtest: params.speedtest ? '1' : '0',
+            pingtest: params.pingtest ? '1' : '0',
+            videoHostPort: params.videoHostPort,
+            audioHostPort: params.audioHostPort,
+        };
+        const res = await this._getJson(`${BASE_PATH}/diagnostics.cgi`, convertedParams, options);
+        return diagnosticsSchema.parse(res);
     }
 }
 export const parseCameraStreamResponse = (cameraStreamData) => {

package/esm/CamSwitcherAPI.js

@@ -1,27 +1,25 @@
 import { z } from 'zod';
-import { AddNewClipError, JsonParseError, ParameterNotFoundError, ErrorWithResponse } from './errors/errors';
+import { AddNewClipError, JsonParseError, ParameterNotFoundError } from './errors/errors';
+import { parseBitrateOptionsToVapixParams, parseVapixParamsToBitrateOptions } from './internal/convertors';
 import { isClip, isNullish } from './internal/utils';
-import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, secondaryAudioSettingsSchema, globalAudioSettingsSchema, } from './types/CamSwitcherAPI';
+import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, secondaryAudioSettingsSchema, globalAudioSettingsSchema, clipFilesListSchema, } from './types/CamSwitcherAPI';
 import { networkCameraListSchema, } from './types/common';
 import { VapixAPI } from './VapixAPI';
-import { isFirmwareVersionAtLeast } from './internal/versionCompare';
-import { FIRMWARE_WITH_BITRATE_MODES_SUPPORT } from './internal/constants';
-import { ProxyClient } from './internal/ProxyClient';
+import { BasicAPI } from './internal/BasicAPI';
 const BASE_PATH = '/local/camswitcher/api';
-export class CamSwitcherAPI {
-    client;
+export class CamSwitcherAPI extends BasicAPI {
     CustomFormData;
     vapixAgent;
     constructor(client, CustomFormData = FormData) {
-        this.client = client;
+        super(client);
         this.CustomFormData = CustomFormData;
         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 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);
@@ -136,7 +134,13 @@ export class CamSwitcherAPI {
         return clipListSchema.parse(res.data).clip_list;
     }
     setCamSwitchOptions(data, cameraFWVersion, options) {
-        const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
+        const bitrateData = {
+            bitrateMode: data.bitrateMode,
+            maximumBitRate: data.maximumBitRate,
+            retentionTime: data.retentionTime,
+            bitRateLimit: data.bitRateLimit,
+        };
+        const bitrateVapixParams = parseBitrateOptionsToVapixParams(cameraFWVersion, data.bitrateMode, bitrateData);
         const saveData = {
             video: {
                 resolution: data.resolution,
@@ -253,25 +257,8 @@ export class CamSwitcherAPI {
         const res = await this.vapixAgent.getParameter([paramName], options);
         return z.string().parse(res[paramName] ?? '');
     }
-    async _getJson(path, parameters, options) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ path, parameters, timeout: options?.timeout });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
-    }
-    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) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
     setParamFromCameraJSON(paramName, data, options) {
         const params = {};
@@ -295,6 +282,20 @@ export class CamSwitcherAPI {
         }
         throw new ParameterNotFoundError(paramName);
     }
+    async getUploadedFileList(clipName, storage, options) {
+        const res = await this._getJson(`${BASE_PATH}/clip_files.cgi`, { clip_name: clipName, storage }, options);
+        return clipFilesListSchema.parse(res).data.files;
+    }
+    async downloadClipFile(fileName, storage, options) {
+        return await this._getBlob(`${BASE_PATH}/clip_download_file.cgi`, { file_name: fileName, storage }, options);
+    }
+    async uploadClipFiles(files, storage, options) {
+        const formData = new FormData();
+        for (const file of files) {
+            formData.append(file.name, file);
+        }
+        await this._post(`${BASE_PATH}/clip_upload_file.cgi`, formData, { storage }, options);
+    }
 }
 const CSW_PARAM_NAMES = {
     SETTINGS: 'Camswitcher.Settings',
@@ -303,62 +304,3 @@ const CSW_PARAM_NAMES = {
     RTSP_TOKEN: 'Camswitcher.RTSPAccessToken',
     DEFAULT_PLAYLIST: 'Camswitcher.DefaultPlaylist',
 };
-const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
-    if (!isFirmwareVersionAtLeast(firmWareVersion, FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
-        return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
-    }
-    if (bitrateMode === undefined) {
-        return '';
-    }
-    const data = {
-        VBR: 'videobitratemode=vbr',
-        MBR: `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}`,
-        ABR: `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`,
-    };
-    return data[bitrateMode];
-};
-const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
-    const params = {};
-    const searchParams = new URLSearchParams(bitrateVapixParams);
-    searchParams.forEach((value, key) => {
-        params[key] = value;
-    });
-    const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
-    const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
-    if (hasLowerFw) {
-        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
-        return {
-            bitrateMode: 'MBR',
-            maximumBitRate: maximumBitRate,
-            retentionTime: 1,
-            bitRateLimit: Math.floor(maximumBitRate * 1.1),
-        };
-    }
-    if (bitrateMode === 'ABR') {
-        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
-        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
-        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
-        return {
-            bitrateMode,
-            maximumBitRate,
-            retentionTime,
-            bitRateLimit,
-        };
-    }
-    else if (bitrateMode === 'MBR') {
-        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
-        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
-        return {
-            bitrateMode: bitrateMode,
-            maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,
-            retentionTime: 1,
-            bitRateLimit: Math.floor(maximumBitRate ?? oldMaximumBitrateParamValue * 1.1),
-        };
-    }
-    return {
-        bitrateMode: bitrateMode,
-        retentionTime: 1,
-        maximumBitRate: 0,
-        bitRateLimit: 0,
-    };
-};

package/esm/PlaneTrackerAPI.js

@@ -1,21 +1,19 @@
 import { z } from 'zod';
-import { paramToUrl } from './internal/utils';
 import { blackListSchema, cameraSettingsSchema, flightInfoSchema, getIcaoSchema, mapInfoSchema, priorityListSchema, serverSettingsSchema, trackingModeSchema, typePriorityListSchema, 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 { CannotSetCoordsInAutoModeError, ImportSettingsError, InvalidAltitudeError, InvalidLatLngError, ResetCalibrationError, ServerError, BadRequestError, } from './errors/errors';
 import { cameraListSchema } from './types/GenetecAgent';
+import { BasicAPI } from './internal/BasicAPI';
 const BASE_PATH = '/local/planetracker';
-export class PlaneTrackerAPI {
-    client;
+export class PlaneTrackerAPI extends BasicAPI {
     apiUser;
     constructor(client, apiUser) {
-        this.client = client;
+        super(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 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);
@@ -23,7 +21,11 @@ export class PlaneTrackerAPI {
     }
     async serverRunCheck(options) {
         const agent = this.getClient(options?.proxyParams);
-        return await agent.get({ path: `${BASE_PATH}/package/serverRunCheck.cgi`, timeout: options?.timeout });
+        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);
@@ -61,7 +63,7 @@ export class PlaneTrackerAPI {
         return cameraSettingsSchema.parse(res);
     }
     async setCameraSettings(settings, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settings, {
+        await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settings, {
             action: 'set',
         }, options);
     }
@@ -120,28 +122,28 @@ export class PlaneTrackerAPI {
         return priorityListSchema.parse(res).priorityList;
     }
     async setPriorityList(priorityList, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, { priorityList }, this.apiUser, 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 typePriorityListSchema.parse(res).typePriorityList;
     }
     async setTypePriorityList(typePriorityList, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setTypePriorityList.cgi`, { typePriorityList }, this.apiUser, 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 whiteListSchema.parse(res).whiteList;
     }
     async setWhiteList(whiteList, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, { whiteList }, this.apiUser, 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 blackListSchema.parse(res).blackList;
     }
     async setBlackList(blackList, options) {
-        return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, { blackList }, this.apiUser, 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);
@@ -179,72 +181,15 @@ export class PlaneTrackerAPI {
             }
         }
     }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
+    }
     async checkGenetecConnection(params, options) {
-        return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, 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 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);
-        }
-    }
 }