camstreamerlib 4.0.0-beta.99 → 4.0.1

package/cjs/PlaneTrackerAPI.js

@@ -2,23 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlaneTrackerAPI = void 0;
 const zod_1 = require("zod");
-const utils_1 = require("./internal/utils");
 const PlaneTrackerAPI_1 = require("./types/PlaneTrackerAPI");
 const errors_1 = require("./errors/errors");
-const ProxyClient_1 = require("./internal/ProxyClient");
 const GenetecAgent_1 = require("./types/GenetecAgent");
+const BasicAPI_1 = require("./internal/BasicAPI");
 const BASE_PATH = '/local/planetracker';
-class PlaneTrackerAPI {
-    client;
+class PlaneTrackerAPI extends BasicAPI_1.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_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);
@@ -26,7 +24,11 @@ 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);
@@ -64,7 +66,7 @@ class PlaneTrackerAPI {
         return PlaneTrackerAPI_1.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);
     }
@@ -123,28 +125,28 @@ class PlaneTrackerAPI {
         return PlaneTrackerAPI_1.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 PlaneTrackerAPI_1.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 PlaneTrackerAPI_1.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 PlaneTrackerAPI_1.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);
@@ -182,73 +184,16 @@ 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 GenetecAgent_1.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 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 _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 errors_1.ErrorWithResponse(res);
-        }
-    }
-    async _postUrlEncoded(path, params, options) {
-        const data = (0, utils_1.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 errors_1.ErrorWithResponse(res);
-        }
-    }
 }
 exports.PlaneTrackerAPI = PlaneTrackerAPI;

package/cjs/VapixAPI.d.ts

@@ -1,17 +1,15 @@
 import { IClient, TParameters, TResponse } from './internal/types';
 import { TAudioDevice, TPortSetSchema, TPortSequenceStateSchema } from './types/VapixAPI';
-import { ProxyClient } from './internal/ProxyClient';
-import { TCameraImageConfig, THttpRequestOptions, TProxyParams } from './types/common';
-export declare class VapixAPI<Client extends IClient<TResponse, any>> {
-    private client;
+import { TCameraImageConfig, THttpRequestOptions } from './types/common';
+import { BasicAPI } from './internal/BasicAPI';
+export declare class VapixAPI<Client extends IClient<TResponse, any>> extends BasicAPI<Client> {
     private CustomFormData;
     constructor(client: Client, CustomFormData?: {
         new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
         prototype: FormData;
     });
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     postUrlEncoded(path: string, parameters?: TParameters, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
-    postJson(path: string, jsonData: Record<string, any>, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
+    postJson(path: string, data: Record<string, any>, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
     getCameraImage(parameters: TCameraImageConfig, options?: THttpRequestOptions): Promise<ReturnType<Client["get"]>>;
     getEventDeclarations(options?: THttpRequestOptions): Promise<string>;
     getSupportedAudioSampleRate(options?: THttpRequestOptions): Promise<{
@@ -19,17 +17,8 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
         bitRates: number[];
     }[]>;
     performAutofocus(options?: THttpRequestOptions): Promise<void>;
-    checkSDCard(options?: THttpRequestOptions): Promise<{
-        status: "OK" | "connected" | "disconnected";
-        totalSize: number;
-        freeSize: number;
-    }>;
-    mountSDCard(options?: THttpRequestOptions): Promise<number>;
-    unmountSDCard(options?: THttpRequestOptions): Promise<number>;
-    private _doSDCardMountAction;
-    fetchSDCardJobProgress(jobId: number, options?: THttpRequestOptions): Promise<number>;
-    downloadCameraReport(options?: THttpRequestOptions): Promise<TResponse>;
-    getSystemLog(options?: THttpRequestOptions): Promise<TResponse>;
+    downloadCameraReport(options?: THttpRequestOptions): Promise<string>;
+    getSystemLog(options?: THttpRequestOptions): Promise<string>;
     getMaxFps(channel: number, options?: THttpRequestOptions): Promise<number>;
     getTimezone(options?: THttpRequestOptions): Promise<string>;
     getDateTimeInfo(options?: THttpRequestOptions): Promise<{
@@ -44,7 +33,16 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     getDevicesSettings(options?: THttpRequestOptions): Promise<TAudioDevice[]>;
     fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, options?: THttpRequestOptions): Promise<any>;
     getHeaders(options?: THttpRequestOptions): Promise<Record<string, string>>;
-    setHeaders(headers: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
+    setHeaders(headers: Record<string, string>, options?: THttpRequestOptions): Promise<void>;
+    checkSDCard(options?: THttpRequestOptions): Promise<{
+        status: "OK" | "connected" | "disconnected";
+        totalSize: number;
+        freeSize: number;
+    }>;
+    mountSDCard(options?: THttpRequestOptions): Promise<number>;
+    unmountSDCard(options?: THttpRequestOptions): Promise<number>;
+    private _doSDCardMountAction;
+    fetchSDCardJobProgress(jobId: number, options?: THttpRequestOptions): Promise<number>;
     getParameter(paramNames: string | string[], options?: THttpRequestOptions): Promise<Record<string, string>>;
     setParameter(params: Record<string, string | number | boolean>, options?: THttpRequestOptions): Promise<void>;
     getGuardTourList(options?: THttpRequestOptions): Promise<{
@@ -52,8 +50,8 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
         id: string;
         running: string;
         tour: {
-            moveSpeed?: unknown;
             position?: unknown;
+            moveSpeed?: unknown;
             presetNbr?: unknown;
             waitTime?: unknown;
             waitTimeViewType?: unknown;
@@ -66,18 +64,18 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     getPTZPresetList(channel: number, options?: THttpRequestOptions): Promise<string[]>;
     listPTZ(camera: number, options?: THttpRequestOptions): Promise<{
         name: string;
-        id: number;
         data: {
             pan?: number | undefined;
             tilt?: number | undefined;
             zoom?: number | undefined;
         };
+        id: number;
     }[]>;
     listPtzVideoSourceOverview(options?: THttpRequestOptions): Promise<Record<number, {
         name: string;
         id: number;
     }[]>>;
-    goToPreset(channel: number, presetName: string, options?: THttpRequestOptions): Promise<TResponse>;
+    goToPreset(channel: number, presetName: string, options?: THttpRequestOptions): Promise<void>;
     getPtzPosition(camera: number, options?: THttpRequestOptions): Promise<{
         pan?: number | undefined;
         tilt?: number | undefined;
@@ -86,15 +84,27 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     getPorts(options?: THttpRequestOptions): Promise<{
         name: string;
         port: string;
+        direction: "output" | "input";
         state: "open" | "closed";
         configurable: boolean;
         usage: string;
-        direction: "input" | "output";
         normalState: "open" | "closed";
         readonly?: boolean | undefined;
     }[]>;
     setPorts(ports: TPortSetSchema[], options?: THttpRequestOptions): Promise<void>;
     setPortStateSequence(port: number, sequence: TPortSequenceStateSchema[], options?: THttpRequestOptions): Promise<void>;
+    addCameraUser(username: string, pass: string, sgrp: string, comment?: string, options?: THttpRequestOptions): Promise<void>;
+    getCameraUsers(options?: THttpRequestOptions): Promise<string[]>;
+    editCameraUser(username: string, pass: string, options?: THttpRequestOptions): Promise<void>;
+    getRecordingRuleList(options?: THttpRequestOptions): Promise<{
+        options: Record<string, string>;
+        diskid: string;
+        eventid: string;
+        profile: string;
+    }[]>;
+    addRecordingRule(params: Record<string, string>, options?: THttpRequestOptions): Promise<string | null>;
+    removeRecordingRule(profileId: string, options?: THttpRequestOptions): Promise<void>;
+    getDiskInfo(diskId?: string, options?: THttpRequestOptions): Promise<boolean>;
     getApplicationList(options?: THttpRequestOptions): Promise<{
         Name: string;
         NiceName: string;
@@ -102,7 +112,7 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
         Version: string;
         License: string;
         Status: string;
-        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | null;
+        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | "CamOverlayHtmlplugin" | null;
         ApplicationID?: string | undefined;
         ConfigurationPage?: string | undefined;
         VendorHomePage?: string | undefined;
@@ -112,7 +122,10 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     restartApplication(applicationId: string, options?: THttpRequestOptions): Promise<void>;
     stopApplication(applicationId: string, options?: THttpRequestOptions): Promise<void>;
     installApplication(data: Parameters<typeof FormData.prototype.append>[1], fileName: string, options?: THttpRequestOptions): Promise<void>;
+    private static parseQueryString;
+    private static checkTextResponseForError;
     private static parseParameters;
     private static parseCameraPtzResponse;
     private static parsePtz;
+    private static parseXmlResponse;
 }