camstreamerlib 4.0.0-beta.99 → 4.0.1

package/cjs/CamStreamerAPI.js

@@ -2,20 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCameraStreamResponse = exports.CamStreamerAPI = void 0;
 const zod_1 = require("zod");
-const ProxyClient_1 = require("./internal/ProxyClient");
 const CamStreamerAPI_1 = require("./types/CamStreamerAPI/CamStreamerAPI");
 const errors_1 = require("./errors/errors");
 const oldStreamSchema_1 = require("./types/CamStreamerAPI/oldStreamSchema");
-const utils_1 = require("./internal/utils");
+const BasicAPI_1 = require("./internal/BasicAPI");
+const CamStreamerAPI_2 = require("./types/CamStreamerAPI");
 const BASE_PATH = '/local/camstreamer';
-class CamStreamerAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
+class CamStreamerAPI extends BasicAPI_1.BasicAPI {
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient_1.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 zod_1.z.boolean().parse(res.data?.state);
     }
     async wsAuthorization(options) {
         const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
@@ -31,19 +32,35 @@ class CamStreamerAPI {
         }
         return zod_1.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 = zod_1.z.record(zod_1.z.string(), oldStreamSchema_1.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,
                 ...(0, exports.parseCameraStreamResponse)(streamData),
             }));
-            throw new errors_1.MigrationError([], data);
+            throw new errors_1.MigrationError([], data, [], []);
         }
         const newStreamData = [];
+        const unknownStreamData = [];
         const oldStreamData = [];
+        const invalidStreamData = [];
         for (const streamData of res.data.streamList) {
+            if (streamData.platform !== undefined && !Object.values(CamStreamerAPI_2.streamPlatforms).includes(streamData.platform)) {
+                unknownStreamData.push(streamData);
+                continue;
+            }
             const newStreamParse = CamStreamerAPI_1.streamSchema.safeParse(streamData);
             if (newStreamParse.success) {
                 newStreamData.push(newStreamParse.data);
@@ -52,20 +69,20 @@ class CamStreamerAPI {
             const oldStreamParse = oldStreamSchema_1.oldStringStreamSchemaWithId.safeParse(streamData);
             if (oldStreamParse.success) {
                 oldStreamData.push({
-                    id: parseInt(oldStreamParse.data.id),
+                    streamId: oldStreamParse.data.streamId,
                     ...(0, exports.parseCameraStreamResponse)(oldStreamParse.data),
                 });
                 continue;
             }
-            throw new Error('Failed to parse some stream entries');
+            invalidStreamData.push(streamData);
         }
-        if (oldStreamData.length > 0) {
-            throw new errors_1.MigrationError(newStreamData, oldStreamData);
+        if (oldStreamData.length > 0 || invalidStreamData.length > 0) {
+            throw new errors_1.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);
     }
@@ -76,17 +93,30 @@ class CamStreamerAPI {
             return newStream.data;
         }
         const oldStream = oldStreamSchema_1.oldStringStreamSchema.passthrough().parse(res.data);
-        throw new errors_1.MigrationError([], [{ id: streamId, ...(0, exports.parseCameraStreamResponse)(oldStream) }]);
+        throw new errors_1.MigrationError([], [{ streamId, ...(0, exports.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 CamStreamerAPI_1.streamStatsSchema.parse(res.data);
+    }
+    async getSrtStreamStatistics(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/srt_statistics.cgi`, { stream_id: streamId }, options);
+        return CamStreamerAPI_1.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);
@@ -99,7 +129,7 @@ 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);
@@ -108,59 +138,21 @@ 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 errors_1.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 errors_1.ErrorWithResponse(res);
-        }
-    }
-    async parseBlobResponse(response) {
-        try {
-            return (await response.blob());
-        }
-        catch (err) {
-            throw new errors_1.ParsingBlobError(err);
-        }
-    }
-    async _postUrlEncoded(path, parameters, options, headers) {
-        const data = (0, utils_1.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 errors_1.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 CamStreamerAPI_1.diagnosticsSchema.parse(res);
     }
 }
 exports.CamStreamerAPI = CamStreamerAPI;

package/cjs/CamSwitcherAPI.d.ts

@@ -1,9 +1,8 @@
 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;
+import { TAudioChannel, THttpRequestOptions, TStorageType } from './types/common';
+import { BasicAPI } from './internal/BasicAPI';
+export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> extends BasicAPI<Client> {
     private CustomFormData;
     private vapixAgent;
     constructor(client: Client, CustomFormData?: {
@@ -13,7 +12,7 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     static getProxyPath: () => string;
     static getWsEventsPath: () => string;
     static getClipPreviewPath: (clipId: string, storage: TStorageType) => string;
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkAPIAvailable(options?: THttpRequestOptions): Promise<void>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     getNetworkCameraList(options?: THttpRequestOptions): Promise<{
         name: string;
@@ -22,9 +21,9 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
     getMaxFps(source: number, options?: THttpRequestOptions): Promise<number>;
     getStorageInfo(options?: THttpRequestOptions): Promise<{
+        size: number;
         storage: "FLASH" | "SD_DISK";
         writable: boolean;
-        size: number;
         available: number;
     }[]>;
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
@@ -39,26 +38,26 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     }>;
     getStreamSaveList(options?: THttpRequestOptions): Promise<Record<string, {
         ip?: string | undefined;
+        enabled?: boolean | undefined;
+        port?: number | undefined;
         niceName?: string | undefined;
         mdnsName?: string | undefined;
-        port?: number | undefined;
-        enabled?: boolean | undefined;
         auth?: string | undefined;
         query?: string | undefined;
-        channel?: "audio" | "video" | "av" | undefined;
+        channel?: "video" | "audio" | "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;
+        channel?: "video" | "audio" | "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;
+        channel?: "video" | "audio" | "av" | undefined;
         keyboard?: Record<string, string | null> | undefined;
         sortIndexOverview?: number | undefined;
         isFavourite?: boolean | undefined;
@@ -87,16 +86,16 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     }>>;
     getTrackerSaveList(options?: THttpRequestOptions): Promise<Record<string, {
         name?: string | undefined;
-        channel?: "audio" | "video" | "av" | undefined;
+        fps?: number | undefined;
+        id?: string | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        duration?: number | undefined;
+        channel?: "video" | "audio" | "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;
@@ -123,11 +122,12 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     removeClip(clipId: string, storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
     getClipList(options?: THttpRequestOptions): Promise<Record<string, {
         storage: "FLASH" | "SD_DISK";
+        duration: number;
         stream_list: ({
             type: "video";
+            fps: number;
             width: number;
             height: number;
-            fps: number;
             sample_rate: number;
             h264_profile: "high" | "main" | "baseline";
             h264_level: "4.1";
@@ -138,7 +138,6 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
             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>;
@@ -147,7 +146,7 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<void>;
     getCamSwitchOptions(options?: THttpRequestOptions): Promise<any>;
     getGlobalAudioSettings(options?: THttpRequestOptions): Promise<{
-        type: "fromSource" | "source";
+        type: "source" | "fromSource";
         source: string;
         storage?: string | undefined;
     }>;
@@ -160,8 +159,10 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
         clipName?: string | undefined;
     }>;
     getPermanentRtspUrlToken(options?: THttpRequestOptions): Promise<string>;
-    private _getJson;
-    private _post;
+    downloadReport(options?: THttpRequestOptions): Promise<string>;
     private setParamFromCameraJSON;
     private getParamFromCameraAndJSONParse;
+    getUploadedFileList(clipName: string, storage: TStorageType, options?: THttpRequestOptions): Promise<string[]>;
+    downloadClipFile(fileName: string, storage: TStorageType, options?: THttpRequestOptions): Promise<ReturnType<Awaited<ReturnType<Client["get"]>>["blob"]>>;
+    uploadClipFiles(files: File[], storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
 }

package/cjs/CamSwitcherAPI.js

@@ -3,28 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamSwitcherAPI = void 0;
 const zod_1 = require("zod");
 const errors_1 = require("./errors/errors");
+const convertors_1 = require("./internal/convertors");
 const utils_1 = require("./internal/utils");
 const CamSwitcherAPI_1 = require("./types/CamSwitcherAPI");
 const common_1 = require("./types/common");
 const VapixAPI_1 = require("./VapixAPI");
-const versionCompare_1 = require("./internal/versionCompare");
-const constants_1 = require("./internal/constants");
-const ProxyClient_1 = require("./internal/ProxyClient");
+const BasicAPI_1 = require("./internal/BasicAPI");
 const BASE_PATH = '/local/camswitcher/api';
-class CamSwitcherAPI {
-    client;
+class CamSwitcherAPI extends BasicAPI_1.BasicAPI {
     CustomFormData;
     vapixAgent;
     constructor(client, CustomFormData = FormData) {
-        this.client = client;
+        super(client);
         this.CustomFormData = CustomFormData;
         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 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);
@@ -139,7 +137,13 @@ class CamSwitcherAPI {
         return CamSwitcherAPI_1.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 = (0, convertors_1.parseBitrateOptionsToVapixParams)(cameraFWVersion, data.bitrateMode, bitrateData);
         const saveData = {
             video: {
                 resolution: data.resolution,
@@ -202,7 +206,7 @@ class CamSwitcherAPI {
             return saveData;
         }
         if (!(0, utils_1.isNullish)(saveData.video?.bitrateVapixParams)) {
-            const bitrateOptions = parseVapixParamsToBitrateOptions(saveData.video.bitrateVapixParams);
+            const bitrateOptions = (0, convertors_1.parseVapixParamsToBitrateOptions)(saveData.video.bitrateVapixParams);
             saveData.video.bitrateMode = bitrateOptions.bitrateMode;
             saveData.video.maximumBitRate = bitrateOptions.maximumBitRate;
             saveData.video.retentionTime = bitrateOptions.retentionTime;
@@ -256,25 +260,8 @@ class CamSwitcherAPI {
         const res = await this.vapixAgent.getParameter([paramName], options);
         return zod_1.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 errors_1.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 errors_1.ErrorWithResponse(res);
-        }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
     setParamFromCameraJSON(paramName, data, options) {
         const params = {};
@@ -298,6 +285,20 @@ class CamSwitcherAPI {
         }
         throw new errors_1.ParameterNotFoundError(paramName);
     }
+    async getUploadedFileList(clipName, storage, options) {
+        const res = await this._getJson(`${BASE_PATH}/clip_files.cgi`, { clip_name: clipName, storage }, options);
+        return CamSwitcherAPI_1.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);
+    }
 }
 exports.CamSwitcherAPI = CamSwitcherAPI;
 const CSW_PARAM_NAMES = {
@@ -307,62 +308,3 @@ const CSW_PARAM_NAMES = {
     RTSP_TOKEN: 'Camswitcher.RTSPAccessToken',
     DEFAULT_PLAYLIST: 'Camswitcher.DefaultPlaylist',
 };
-const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
-    if (!(0, versionCompare_1.isFirmwareVersionAtLeast)(firmWareVersion, constants_1.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/cjs/PlaneTrackerAPI.d.ts

@@ -1,16 +1,15 @@
-import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
+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, TProxyParams } from './types/common';
-import { ProxyClient } from './internal/ProxyClient';
-export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
-    private client;
+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;
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkAPIAvailable(options?: THttpRequestOptions): Promise<void>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
-    serverRunCheck(options?: THttpRequestOptions): Promise<TResponse>;
+    serverRunCheck(options?: THttpRequestOptions): Promise<boolean>;
     getLiveViewAlias(rtspUrl: string, options?: THttpRequestOptions): Promise<{
         ws: string;
         ws_initial_message: string;
@@ -22,11 +21,12 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
         camera: {
             ip: string;
             port: number;
-            protocol: "https" | "http" | "https_insecure";
-            user: string;
             pass: string;
+            user: string;
+            protocol: "https" | "http" | "https_insecure";
         };
         units: "metric" | "imperial";
+        trackingDomain: "adsb" | "dronetag";
         adsbSource: {
             ip: string;
             port: number;
@@ -84,8 +84,8 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
         };
         radarcapeFlightInfoSource: {
             ip: string;
-            port: number;
             enabled: boolean;
+            port: number;
             priority: number;
         };
         identificationLabel: {
@@ -97,22 +97,22 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
         };
         acs: {
             ip: string;
-            port: number;
             enabled: boolean;
-            protocol: "https" | "http" | "https_insecure";
-            user: string;
+            port: number;
             pass: string;
+            user: string;
+            protocol: "https" | "http" | "https_insecure";
             sourceKey: string;
         };
         genetec: {
             ip: string;
-            port: number;
             enabled: boolean;
+            port: number;
             cameraList: string[];
+            pass: string;
             appId: string;
-            protocol: "https" | "http" | "https_insecure";
             user: string;
-            pass: string;
+            protocol: "https" | "http" | "https_insecure";
             baseUri: string;
         };
         camstreamerIntegration: {
@@ -132,18 +132,20 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
             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;
-            displayAircraftInfo?: boolean | undefined;
+            displaySystemInfo?: boolean | undefined;
         } | undefined;
     }>;
-    setCameraSettings(settings: TCameraSettings, options?: THttpRequestOptions): Promise<TResponse>;
+    setCameraSettings(settings: TCameraSettings, options?: THttpRequestOptions): Promise<void>;
     fetchServerSettings(options?: THttpRequestOptions): Promise<{
         cameraCalibration: {
             posLat: number;
@@ -162,7 +164,7 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
             }[];
         };
     }>;
-    exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
+    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: {
@@ -193,13 +195,13 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
     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>;
+    setPriorityList(priorityList: TPriorityList['priorityList'], options?: THttpRequestOptions): Promise<void>;
     getTypePriorityList(options?: THttpRequestOptions): Promise<string[]>;
-    setTypePriorityList(typePriorityList: TTypePriorityList['typePriorityList'], options?: THttpRequestOptions): Promise<TResponse>;
+    setTypePriorityList(typePriorityList: TTypePriorityList['typePriorityList'], options?: THttpRequestOptions): Promise<void>;
     getWhiteList(options?: THttpRequestOptions): Promise<string[]>;
-    setWhiteList(whiteList: TWhiteList['whiteList'], options?: THttpRequestOptions): Promise<TResponse>;
+    setWhiteList(whiteList: TWhiteList['whiteList'], options?: THttpRequestOptions): Promise<void>;
     getBlackList(options?: THttpRequestOptions): Promise<string[]>;
-    setBlackList(blackList: TBlackList['blackList'], options?: THttpRequestOptions): Promise<TResponse>;
+    setBlackList(blackList: TBlackList['blackList'], options?: THttpRequestOptions): Promise<void>;
     fetchMapInfo(options?: THttpRequestOptions): Promise<{
         minZoom: number;
         maxZoom: number;
@@ -227,15 +229,11 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
     }>;
     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>;
+    downloadReport(options?: THttpRequestOptions): Promise<string>;
+    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<boolean>;
     getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<{
         value: string;
-        index: number;
         label: string;
+        index: number;
     }[]>;
-    private _getJson;
-    private _getBlob;
-    private parseBlobResponse;
-    private _postJsonEncoded;
-    private _postUrlEncoded;
 }