camstreamerlib 4.0.0-beta.29 → 4.0.0-beta.30

package/esm/CamOverlayAPI.js

@@ -1,94 +1,100 @@
 import { paramToUrl, responseStringify } from './internal/utils';
-import { ImageType, } from './types/CamOverlayAPI';
 import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
 import { z } from 'zod';
-import { widgetsSchema } from './models/CamOverlayAPI/widgetsSchema';
-import { fileListSchema, storageSchema } from './models/CamOverlayAPI/fileSchema';
-export const BASE_URL = '/local/camoverlay/api';
+import { ProxyClient } from './internal/ProxyClient';
+import { fileListSchema, ImageType, storageDataListSchema, widgetsSchema, WSResponseSchema, } from './types/CamOverlayAPI/CamOverlayAPI';
+export const allowedWidgetNames = {
+    accuweather: 'accuweather',
+    infoticker: 'infoticker',
+    customGraphics: 'customGraphics',
+    ptzCompass: 'ptzCompass',
+    images: 'images',
+    ptz: 'ptz',
+    pip: 'pip',
+    screenSharing: 'screenSharing',
+    web_camera: 'web_camera',
+};
+const BASE_PATH = '/local/camoverlay/api';
 export class CamOverlayAPI {
     client;
     constructor(client) {
         this.client = client;
     }
-    static getProxyUrlPath = () => `${BASE_URL}/proxy.cgi`;
-    static getFilePreviewPath = (path) => `${BASE_URL}/image.cgi?path=${encodeURIComponent(path)}`;
-    async checkCameraTime() {
-        const response = await this._get(`${BASE_URL}/camera_time.cgi`);
+    static getBasePath = () => BASE_PATH;
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getFilePreviewPath = (path) => `${BASE_PATH}/image.cgi?path=${encodeURIComponent(path)}`;
+    async checkCameraTime(options) {
+        const response = await this._get({ path: `${BASE_PATH}/camera_time.cgi` }, options);
         return z.boolean().parse(response.state);
     }
-    async getNetworkCameraList() {
-        const response = await this._get(`${BASE_URL}/network_camera_list.cgi`);
+    async getNetworkCameraList(options) {
+        const response = await this._get({ path: `${BASE_PATH}/network_camera_list.cgi` }, options);
         return networkCameraListSchema.parse(response.camera_list);
     }
-    async wsAuthorization() {
-        const responseSchema = z.object({
-            status: z.number(),
-            message: z.string(),
-            data: z.string(),
-        });
-        const response = await this._get(`${BASE_URL}/ws_authorization.cgi`);
-        return responseSchema.parse(response).data;
-    }
-    async getMjpegStreamImage(mjpegUrl) {
-        return await this._getBlob(`${BASE_URL}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
-    }
-    async listFiles(fileType) {
-        const fileDataSchema = z.object({
-            code: z.number(),
-            list: fileListSchema,
-        });
-        const files = await this._get(`${BASE_URL}/upload_${fileType}.cgi`, {
-            action: 'list',
-        });
+    async wsAuthorization(options) {
+        const response = await this._get({ path: `${BASE_PATH}/ws_authorization.cgi` }, options);
+        return WSResponseSchema.parse(response).data;
+    }
+    async getMjpegStreamImage(mjpegUrl, options) {
+        return await this._getBlob({
+            path: `${BASE_PATH}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`,
+        }, options);
+    }
+    async listFiles(fileType, options) {
+        const files = await this._get({
+            path: `${BASE_PATH}/upload_${fileType}.cgi`,
+            parameters: {
+                action: 'list',
+            },
+        }, options);
         return fileListSchema.parse(files.list);
     }
-    async uploadFile(fileType, formData, storage) {
-        const path = `${BASE_URL}/upload_${fileType}.cgi`;
-        await this._post(path, formData, {
-            action: 'upload',
-            storage: storage,
-        });
-    }
-    async removeFile(fileType, fileParams) {
-        const path = `${BASE_URL}/upload_${fileType}.cgi`;
+    async uploadFile(fileType, formData, storage, options) {
+        await this._post({
+            path: `${BASE_PATH}/upload_${fileType}.cgi`,
+            data: formData,
+            parameters: {
+                action: 'upload',
+                storage: storage,
+            },
+        }, options);
+    }
+    async removeFile(fileType, fileParams, options) {
+        const path = `${BASE_PATH}/upload_${fileType}.cgi`;
         await this._postUrlEncoded(path, {
             action: 'remove',
             ...fileParams,
-        });
-    }
-    async getFileStorage(fileType) {
-        const storageDataListSchema = z.array(z.object({
-            type: storageSchema,
-            state: z.string(),
-        }));
-        const responseSchema = z.object({
-            code: z.number(),
-            list: storageDataListSchema,
-        });
-        const data = await this._get(`${BASE_URL}/upload_${fileType}.cgi`, {
-            action: 'get_storage',
-        });
+        }, undefined, options);
+    }
+    async getFileStorage(fileType, options) {
+        const data = await this._get({
+            path: `${BASE_PATH}/upload_${fileType}.cgi`,
+            parameters: {
+                action: 'get_storage',
+            },
+        }, options);
         if (data.code !== 200) {
             throw new Error('Error occured while fetching file storage data');
         }
         return storageDataListSchema.parse(data.list);
     }
-    async getFilePreviewFromCamera(path) {
-        return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path));
+    async getFilePreviewFromCamera(path, options) {
+        return await this._getBlob({ path: CamOverlayAPI.getFilePreviewPath(path) }, options);
     }
-    async updateInfoticker(serviceID, text) {
-        await this._get(`${BASE_URL}/infoticker.cgi?service_id=${serviceID}&text=${text}`);
+    async updateInfoticker(serviceId, text, options) {
+        await this._get({ path: `${BASE_PATH}/infoticker.cgi?service_id=${serviceId}&text=${text}` }, options);
     }
-    async setEnabled(serviceID, enabled) {
-        await this._post(`${BASE_URL}/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
+    async setEnabled(serviceId, enabled, options) {
+        await this._post({ path: `${BASE_PATH}/enabled.cgi?id_${serviceId}=${enabled ? 1 : 0}`, data: '' }, options);
     }
-    async isEnabled(serviceID) {
-        const res = await this.client.get(`${BASE_URL}/services.cgi?action=get`);
+    async isEnabled(serviceId, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ path: `${BASE_PATH}/services.cgi?action=get`, timeout: options?.timeout });
         if (res.ok) {
             const data = JSON.parse(await res.text());
             for (const service of data.services) {
-                if (service.id === serviceID) {
+                if (service.id === serviceId) {
                     return service.enabled === 1;
                 }
             }
@@ -98,17 +104,23 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async getSingleWidget(serviceId) {
-        const data = await this._get(`${BASE_URL}/services.cgi`, {
-            action: 'get',
-            service_id: serviceId.toString(),
-        });
+    async getSingleWidget(serviceId, options) {
+        const data = await this._get({
+            path: `${BASE_PATH}/services.cgi`,
+            parameters: {
+                action: 'get',
+                service_id: serviceId.toString(),
+            },
+        }, options);
         return widgetsSchema.parse(data);
     }
-    async getWidgets() {
-        const widgetList = await this._get(`${BASE_URL}/services.cgi`, {
-            action: 'get',
-        });
+    async getWidgets(options) {
+        const widgetList = await this._get({
+            path: `${BASE_PATH}/services.cgi`,
+            parameters: {
+                action: 'get',
+            },
+        }, options);
         const widgets = widgetList.services;
         widgets.forEach((widget) => {
             const parsedWidget = widgetsSchema.safeParse(widget);
@@ -118,20 +130,20 @@ export class CamOverlayAPI {
         });
         return widgets;
     }
-    async updateSingleWidget(widget) {
-        const path = `${BASE_URL}/services.cgi`;
+    async updateSingleWidget(widget, options) {
+        const path = `${BASE_PATH}/services.cgi`;
         await this._postJsonEncoded(path, JSON.stringify(widget), {
             action: 'set',
             service_id: widget.id.toString(),
-        });
+        }, undefined, options);
     }
-    async updateWidgets(widgets) {
-        const path = `${BASE_URL}/services.cgi`;
+    async updateWidgets(widgets, options) {
+        const path = `${BASE_PATH}/services.cgi`;
         await this._postJsonEncoded(path, JSON.stringify({ services: widgets }), {
             action: 'set',
-        });
+        }, undefined, options);
     }
-    updateCGText(serviceID, fields) {
+    updateCGText(serviceId, fields, options) {
         const params = {};
         for (const field of fields) {
             const name = field.field_name;
@@ -140,51 +152,59 @@ export class CamOverlayAPI {
                 params[`${name}_color`] = field.color;
             }
         }
-        return this.promiseCGUpdate(serviceID, 'update_text', params);
+        return this.promiseCGUpdate(serviceId, 'update_text', params, undefined, undefined, options);
     }
-    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
+    updateCGImagePos(serviceId, coordinates = '', x = 0, y = 0, options) {
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, undefined, undefined, options);
     }
-    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
+    updateCGImage(serviceId, path, coordinates = '', x = 0, y = 0, options) {
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
             image: path,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, undefined, undefined, options);
     }
-    updateCGImageFromData(serviceID, imageType, imageData, coordinates = '', x = 0, y = 0) {
+    updateCGImageFromData(serviceId, imageType, imageData, coordinates = '', x = 0, y = 0, options) {
         const contentType = imageType === ImageType.PNG ? 'image/png' : 'image/jpeg';
         const params = {
             coord_system: coordinates,
             pos_x: x,
             pos_y: y,
         };
-        return this.promiseCGUpdate(serviceID, 'update_image', params, contentType, imageData);
+        return this.promiseCGUpdate(serviceId, 'update_image', params, contentType, imageData, options);
     }
-    async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
-        const path = `${BASE_URL}/customGraphics.cgi`;
+    async promiseCGUpdate(serviceId, action, params = {}, contentType, data, options) {
+        const path = `${BASE_PATH}/customGraphics.cgi`;
         let headers = {};
         if (contentType !== undefined && data) {
             headers = { 'Content-Type': contentType };
         }
-        const res = await this.client.post(path, data ?? '', {
-            action: action,
-            service_id: serviceID.toString(),
-            ...params,
-        }, headers);
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data: data ?? '',
+            parameters: {
+                action: action,
+                service_id: serviceId.toString(),
+                ...params,
+            },
+            headers,
+            timeout: options?.timeout,
+        });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
     }
-    async _get(...args) {
-        const res = await this.client.get(...args);
+    async _get(params, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ ...params, timeout: options?.timeout });
         if (res.ok) {
             return (await res.json());
         }
@@ -192,8 +212,9 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async _post(...args) {
-        const res = await this.client.post(...args);
+    async _post(params, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({ ...params, timeout: options?.timeout });
         if (res.ok) {
             return (await res.json());
         }
@@ -201,8 +222,9 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async _getBlob(...args) {
-        const res = await this.client.get(...args);
+    async _getBlob(params, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ ...params, timeout: options?.timeout });
         if (res.ok) {
             return await this.parseBlobResponse(res);
         }
@@ -218,14 +240,16 @@ export class CamOverlayAPI {
             throw new ParsingBlobError(err);
         }
     }
-    async _postUrlEncoded(path, params, headers) {
+    async _postUrlEncoded(path, params, headers, options) {
         const data = paramToUrl(params);
         const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
-        return this._post(path, data, {}, { ...baseHeaders, ...headers });
+        return this._post({ path, data, headers: { ...baseHeaders, ...headers } }, options);
     }
-    async _postJsonEncoded(...args) {
-        const [path, data, params, headers] = args;
+    async _postJsonEncoded(path, data, parameters, headers, options) {
         const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        return this._post(path, data, params, { ...baseHeaders, ...headers });
+        return this._post({ path, data, parameters, headers: { ...baseHeaders, ...headers } }, options);
+    }
+    getAgent(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
     }
 }

package/esm/CamOverlayDrawingAPI.d.ts

@@ -1,53 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import * as EventEmitter from 'events';
-import { WsOptions } from './internal/types';
-export type CamOverlayDrawingOptions = WsOptions & {
-    camera?: number | number[];
-    zIndex?: number;
-};
-export type TCairoResponse = {
-    message: string;
-    call_id: number;
-};
-export type TCairoCreateResponse = {
-    var: string;
-    call_id: number;
-};
-export type TUploadImageResponse = {
-    var: string;
-    width: number;
-    height: number;
-    call_id: number;
-};
-export type TErrorResponse = {
-    error: string;
-    call_id?: number;
-};
-export type TService = {
-    id: number;
-    enabled: number;
-    schedule: string;
-    name: string;
-    identifier: string;
-    cameraList: number[];
-};
-export type TServiceList = {
-    services: TService[];
-};
-export type TAlign = 'A_RIGHT' | 'A_LEFT' | 'A_CENTER';
-export type TextFit = 'TFM_SCALE' | 'TFM_TRUNCATE' | 'TFM_OVERFLOW';
-export type TWriteTextParams = [string, string, number, number, number, number, TAlign, TextFit?];
-export interface CamOverlayDrawingAPI {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'error', listener: (err: Error) => void): this;
-    on(event: 'message', listener: (msg: string) => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'error', err: Error): boolean;
-    emit(event: 'message', msg: string): boolean;
-}
+import { CamOverlayDrawingOptions, TCairoCreateResponse, TCairoResponse, TUploadImageResponse, TWriteTextParams } from './types/CamOverlayDrawingAPI';
 export declare class CamOverlayDrawingAPI extends EventEmitter {
     private tls;
     private tlsInsecure;

package/esm/CamOverlayPainter/Frame.d.ts

@@ -1,42 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { CamOverlayDrawingAPI, TAlign, TCairoCreateResponse, TUploadImageResponse } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
-export type TRgb = [number, number, number];
-export type TRgba = [number, number, number, number];
-export type TTmf = 'TFM_OVERFLOW' | 'TFM_SCALE' | 'TFM_TRUNCATE';
-export type TObjectFitType = 'fill' | 'fit' | 'none';
-export type TFrameOptions = {
-    enabled?: boolean;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    text?: string;
-    fontColor?: TRgb;
-    font?: string;
-    bgColor?: TRgba;
-    bgImage?: string;
-    bgType?: TObjectFitType;
-    borderRadius?: number;
-    borderWidth?: number;
-    borderColor?: TRgba;
-    customDraw?: TDrawingCallback;
-    layer?: number;
-};
-export type TFrameInfo = {
-    width: number;
-    height: number;
-};
-export type TDrawingCallback = (cod: CamOverlayDrawingAPI, cairo: string, info: TFrameInfo) => Promise<void>;
-export interface Frame {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'layoutChanged', listener: () => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'layoutChanged'): boolean;
-}
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { TAlign, TCairoCreateResponse, TUploadImageResponse } from '../types/CamOverlayDrawingAPI';
+import { ResourceManager } from './ResourceManager';
+import { TBg, TBorder, TDrawingCallback, TFrame, TFrameOptions, TObjectFitType, TRgb, TRgba, TText, TTmf } from '../types/CamOverlayPainter';
 export declare class Frame extends EventEmitter {
     protected enabled: boolean;
     protected posX: number;
@@ -64,17 +31,21 @@ export declare class Frame extends EventEmitter {
     disable(): void;
     setFramePosition(x: number, y: number): void;
     setFrameSize(width: number, height: number): void;
+    getFrameInfo(): TFrame;
     setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
     setFontColor(fontColor: TRgb): void;
     setFont(fontName: string): void;
     setFontData(fontData: TCairoCreateResponse): void;
+    getTextInfo(): TText;
     setBgColor(color: TRgba): void;
     setBgImage(imageName: string, type?: TObjectFitType): void;
     setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
     setBgType(type: TObjectFitType): void;
+    getBgInfo(): TBg;
     setBorderRadius(radius: number): void;
     setBorderWidth(width: number): void;
     setBorderColor(color: TRgba): void;
+    getBorderInfo(): TBorder;
     setCustomDraw(customDraw: TDrawingCallback): void;
     resetFont(): void;
     resetBgColor(): void;

package/esm/CamOverlayPainter/Frame.js

@@ -54,6 +54,14 @@ export class Frame extends EventEmitter {
         this.width = width;
         this.height = height;
     }
+    getFrameInfo() {
+        return {
+            x: this.posX,
+            y: this.posY,
+            width: this.width,
+            height: this.height,
+        };
+    }
     setText(text, align, textType = 'TFM_OVERFLOW', fontColor) {
         this.text = text;
         this.align = align;
@@ -73,6 +81,16 @@ export class Frame extends EventEmitter {
         this.fontName = undefined;
         this.font = fontData;
     }
+    getTextInfo() {
+        return {
+            text: this.text,
+            textAlign: this.align,
+            textType: this.textType,
+            fontColor: this.fontColor,
+            font: this.font,
+            fontName: this.fontName,
+        };
+    }
     setBgColor(color) {
         this.bgColor = color;
     }
@@ -89,6 +107,14 @@ export class Frame extends EventEmitter {
     setBgType(type) {
         this.bgType = type;
     }
+    getBgInfo() {
+        return {
+            bgColor: this.bgColor,
+            bgImage: this.bgImage,
+            bgImageName: this.bgImageName,
+            bgType: this.bgType,
+        };
+    }
     setBorderRadius(radius) {
         this.borderRadius = radius;
     }
@@ -98,6 +124,13 @@ export class Frame extends EventEmitter {
     setBorderColor(color) {
         this.borderColor = color;
     }
+    getBorderInfo() {
+        return {
+            borderRadius: this.borderRadius,
+            borderWidth: this.borderWidth,
+            borderColor: this.borderColor,
+        };
+    }
     setCustomDraw(customDraw) {
         this.customDraw = customDraw;
     }

package/esm/CamOverlayPainter/Painter.d.ts

@@ -1,6 +1,8 @@
-import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
-import { Frame, TFrameOptions } from './Frame';
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { CamOverlayDrawingOptions } from '../types/CamOverlayDrawingAPI';
+import { ResourceManager } from './ResourceManager';
+import { Frame } from './Frame';
+import { TCoAlignment, TPainterOptions } from '../types/CamOverlayPainter';
 export declare const COORD: {
     readonly top_left: readonly [-1, -1];
     readonly center_left: readonly [-1, 0];
@@ -12,12 +14,6 @@ export declare const COORD: {
     readonly center_right: readonly [1, 0];
     readonly bottom_right: readonly [1, 1];
 };
-type TCoAlignment = keyof typeof COORD;
-export type TPainterOptions = TFrameOptions & {
-    screenWidth: number;
-    screenHeight: number;
-    coAlignment: TCoAlignment;
-};
 export declare class Painter extends Frame {
     private screenWidth;
     private screenHeight;
@@ -45,4 +41,3 @@ export declare class Painter extends Frame {
     private cleanupSurface;
     private positionConvertor;
 }
-export { Frame, TFrameOptions as FrameOptions, ResourceManager, CamOverlayDrawingOptions };

package/esm/CamOverlayPainter/Painter.js

@@ -1,5 +1,5 @@
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
+import { ResourceManager } from './ResourceManager';
 import { Frame } from './Frame';
 export const COORD = {
     top_left: [-1, -1],
@@ -163,4 +163,3 @@ export class Painter extends Frame {
         }
     }
 }
-export { Frame, ResourceManager };

package/esm/CamOverlayPainter/ResourceManager.d.ts

@@ -1,5 +1,6 @@
-import { CamOverlayDrawingAPI, TUploadImageResponse, TCairoCreateResponse } from '../CamOverlayDrawingAPI';
-export default class ResourceManager {
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { TUploadImageResponse, TCairoCreateResponse } from '../types/CamOverlayDrawingAPI';
+export declare class ResourceManager {
     private co;
     private imgFileNames;
     private fontFileNames;

package/esm/CamOverlayPainter/ResourceManager.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs/promises';
-export default class ResourceManager {
+export class ResourceManager {
     co;
     imgFileNames = {};
     fontFileNames = {};

package/esm/CamScripterAPI.d.ts

@@ -1,36 +1,36 @@
 import { IClient, TResponse } from './internal/types';
 import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
-import { TNetworkCamera } from './types/common';
-export declare const BASE_URL = "/local/camscripter";
+import { THttpRequestOptions, TNetworkCamera } from './types/common';
 export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     client: Client;
     constructor(client: Client);
     static getProxyUrlPath: () => string;
-    checkCameraTime(): Promise<boolean>;
-    getNetworkCameraList(): Promise<TNetworkCamera[]>;
-    getStorageInfo(): Promise<TStorage>;
-    getPackageList(): Promise<TPackageInfoList>;
-    installPackages(formData: FormData, storage: TStorageType): Promise<{
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<TStorage>;
+    getPackageList(options?: THttpRequestOptions): Promise<TPackageInfoList>;
+    installPackages(formData: FormData, storage: TStorageType, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
-    uninstallPackage(packageId: string): Promise<{
+    uninstallPackage(packageId: string, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
-    importSettings(packageId: string, formData: FormData): Promise<{
+    importSettings(packageId: string, formData: FormData, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
-    exportSettings(packageId: string, formData: FormData): Promise<{
+    exportSettings(packageId: string, formData: FormData, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
-    getNodejsStatus(): Promise<TNodeState>;
-    installNodejs(storage: TStorageType): Promise<{
+    getNodejsStatus(options?: THttpRequestOptions): Promise<TNodeState>;
+    installNodejs(storage: TStorageType, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
     private get;
     private post;
+    private getAgent;
 }