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

package/cjs/CamOverlayAPI.js

@@ -1,97 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamOverlayAPI = exports.BASE_URL = void 0;
+exports.CamOverlayAPI = exports.allowedWidgetNames = void 0;
 const utils_1 = require("./internal/utils");
-const CamOverlayAPI_1 = require("./types/CamOverlayAPI");
 const errors_1 = require("./errors/errors");
 const common_1 = require("./types/common");
 const zod_1 = require("zod");
-const widgetsSchema_1 = require("./models/CamOverlayAPI/widgetsSchema");
-const fileSchema_1 = require("./models/CamOverlayAPI/fileSchema");
-exports.BASE_URL = '/local/camoverlay/api';
+const ProxyClient_1 = require("./internal/ProxyClient");
+const CamOverlayAPI_1 = require("./types/CamOverlayAPI/CamOverlayAPI");
+exports.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';
 class CamOverlayAPI {
     client;
     constructor(client) {
         this.client = client;
     }
-    static getProxyUrlPath = () => `${exports.BASE_URL}/proxy.cgi`;
-    static getFilePreviewPath = (path) => `${exports.BASE_URL}/image.cgi?path=${encodeURIComponent(path)}`;
-    async checkCameraTime() {
-        const response = await this._get(`${exports.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 zod_1.z.boolean().parse(response.state);
     }
-    async getNetworkCameraList() {
-        const response = await this._get(`${exports.BASE_URL}/network_camera_list.cgi`);
+    async getNetworkCameraList(options) {
+        const response = await this._get({ path: `${BASE_PATH}/network_camera_list.cgi` }, options);
         return common_1.networkCameraListSchema.parse(response.camera_list);
     }
-    async wsAuthorization() {
-        const responseSchema = zod_1.z.object({
-            status: zod_1.z.number(),
-            message: zod_1.z.string(),
-            data: zod_1.z.string(),
-        });
-        const response = await this._get(`${exports.BASE_URL}/ws_authorization.cgi`);
-        return responseSchema.parse(response).data;
+    async wsAuthorization(options) {
+        const response = await this._get({ path: `${BASE_PATH}/ws_authorization.cgi` }, options);
+        return CamOverlayAPI_1.WSResponseSchema.parse(response).data;
     }
-    async getMjpegStreamImage(mjpegUrl) {
-        return await this._getBlob(`${exports.BASE_URL}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
+    async getMjpegStreamImage(mjpegUrl, options) {
+        return await this._getBlob({
+            path: `${BASE_PATH}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`,
+        }, options);
     }
-    async listFiles(fileType) {
-        const fileDataSchema = zod_1.z.object({
-            code: zod_1.z.number(),
-            list: fileSchema_1.fileListSchema,
-        });
-        const files = await this._get(`${exports.BASE_URL}/upload_${fileType}.cgi`, {
-            action: 'list',
-        });
-        return fileSchema_1.fileListSchema.parse(files.list);
+    async listFiles(fileType, options) {
+        const files = await this._get({
+            path: `${BASE_PATH}/upload_${fileType}.cgi`,
+            parameters: {
+                action: 'list',
+            },
+        }, options);
+        return CamOverlayAPI_1.fileListSchema.parse(files.list);
     }
-    async uploadFile(fileType, formData, storage) {
-        const path = `${exports.BASE_URL}/upload_${fileType}.cgi`;
-        await this._post(path, formData, {
-            action: 'upload',
-            storage: storage,
-        });
+    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) {
-        const path = `${exports.BASE_URL}/upload_${fileType}.cgi`;
+    async removeFile(fileType, fileParams, options) {
+        const path = `${BASE_PATH}/upload_${fileType}.cgi`;
         await this._postUrlEncoded(path, {
             action: 'remove',
             ...fileParams,
-        });
+        }, undefined, options);
     }
-    async getFileStorage(fileType) {
-        const storageDataListSchema = zod_1.z.array(zod_1.z.object({
-            type: fileSchema_1.storageSchema,
-            state: zod_1.z.string(),
-        }));
-        const responseSchema = zod_1.z.object({
-            code: zod_1.z.number(),
-            list: storageDataListSchema,
-        });
-        const data = await this._get(`${exports.BASE_URL}/upload_${fileType}.cgi`, {
-            action: 'get_storage',
-        });
+    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);
+        return CamOverlayAPI_1.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(`${exports.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(`${exports.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(`${exports.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;
                 }
             }
@@ -101,40 +107,46 @@ class CamOverlayAPI {
             throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async getSingleWidget(serviceId) {
-        const data = await this._get(`${exports.BASE_URL}/services.cgi`, {
-            action: 'get',
-            service_id: serviceId.toString(),
-        });
-        return widgetsSchema_1.widgetsSchema.parse(data);
+    async getSingleWidget(serviceId, options) {
+        const data = await this._get({
+            path: `${BASE_PATH}/services.cgi`,
+            parameters: {
+                action: 'get',
+                service_id: serviceId.toString(),
+            },
+        }, options);
+        return CamOverlayAPI_1.widgetsSchema.parse(data);
     }
-    async getWidgets() {
-        const widgetList = await this._get(`${exports.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_1.widgetsSchema.safeParse(widget);
+            const parsedWidget = CamOverlayAPI_1.widgetsSchema.safeParse(widget);
             if (!parsedWidget.success) {
                 console.warn(`[SERVICE SCHEMA MISMATCH]: Service ${widget.name} (${widget.id}) does not match the current schema, or is a hidden service.`);
             }
         });
         return widgets;
     }
-    async updateSingleWidget(widget) {
-        const path = `${exports.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 = `${exports.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;
@@ -143,51 +155,59 @@ 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 === CamOverlayAPI_1.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 = `${exports.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 (0, utils_1.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());
         }
@@ -195,8 +215,9 @@ class CamOverlayAPI {
             throw new Error(await (0, utils_1.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());
         }
@@ -204,8 +225,9 @@ class CamOverlayAPI {
             throw new Error(await (0, utils_1.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);
         }
@@ -221,15 +243,17 @@ class CamOverlayAPI {
             throw new errors_1.ParsingBlobError(err);
         }
     }
-    async _postUrlEncoded(path, params, headers) {
+    async _postUrlEncoded(path, params, headers, options) {
         const data = (0, utils_1.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_1.ProxyClient(this.client, proxyParams) : this.client;
     }
 }
 exports.CamOverlayAPI = CamOverlayAPI;

package/cjs/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/cjs/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/cjs/CamOverlayPainter/Frame.js

@@ -57,6 +57,14 @@ class Frame extends events_1.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;
@@ -76,6 +84,16 @@ class Frame extends events_1.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;
     }
@@ -92,6 +110,14 @@ class Frame extends events_1.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;
     }
@@ -101,6 +127,13 @@ class Frame extends events_1.EventEmitter {
     setBorderColor(color) {
         this.borderColor = color;
     }
+    getBorderInfo() {
+        return {
+            borderRadius: this.borderRadius,
+            borderWidth: this.borderWidth,
+            borderColor: this.borderColor,
+        };
+    }
     setCustomDraw(customDraw) {
         this.customDraw = customDraw;
     }

package/cjs/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/cjs/CamOverlayPainter/Painter.js

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceManager = exports.Frame = exports.Painter = exports.COORD = void 0;
+exports.Painter = exports.COORD = void 0;
 const CamOverlayDrawingAPI_1 = require("../CamOverlayDrawingAPI");
 const ResourceManager_1 = require("./ResourceManager");
-exports.ResourceManager = ResourceManager_1.default;
 const Frame_1 = require("./Frame");
-Object.defineProperty(exports, "Frame", { enumerable: true, get: function () { return Frame_1.Frame; } });
 exports.COORD = {
     top_left: [-1, -1],
     center_left: [-1, 0],
@@ -31,7 +29,7 @@ class Painter extends Frame_1.Frame {
         this.screenWidth = opt.screenWidth;
         this.screenHeight = opt.screenHeight;
         this.cod = new CamOverlayDrawingAPI_1.CamOverlayDrawingAPI(coopt);
-        this.rm = new ResourceManager_1.default(this.cod);
+        this.rm = new ResourceManager_1.ResourceManager(this.cod);
     }
     get camOverlayDrawingAPI() {
         return this.cod;

package/cjs/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/cjs/CamOverlayPainter/ResourceManager.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceManager = void 0;
 const fs = require("fs/promises");
 class ResourceManager {
     co;
@@ -43,4 +44,4 @@ class ResourceManager {
         this.fonts = {};
     }
 }
-exports.default = ResourceManager;
+exports.ResourceManager = ResourceManager;

package/cjs/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;
 }