camstreamerlib 4.0.0-beta.3 → 4.0.0-beta.30

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,11 +1,18 @@
-import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
-import { Frame, TFrameOptions } from './Frame';
-export declare const COORD: Record<string, [number, number]>;
-export type TPainterOptions = TFrameOptions & {
-    screenWidth: number;
-    screenHeight: number;
-    coAlignment: string;
+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];
+    readonly bottom_left: readonly [-1, 1];
+    readonly top_center: readonly [0, -1];
+    readonly center: readonly [0, 0];
+    readonly bottom_center: readonly [0, 1];
+    readonly top_right: readonly [1, -1];
+    readonly center_right: readonly [1, 0];
+    readonly bottom_right: readonly [1, 1];
 };
 export declare class Painter extends Frame {
     private screenWidth;
@@ -24,7 +31,7 @@ export declare class Painter extends Frame {
     registerImage(moniker: string, fileName: string): void;
     registerFont(moniker: string, fileName: string): void;
     setScreenSize(sw: number, sh: number): void;
-    setCoAlignment(coAlignment: string): void;
+    setCoAlignment(coAlignment: TCoAlignment): void;
     protected layoutChanged(): void;
     display(scale?: number): Promise<void>;
     hide(): Promise<void>;
@@ -34,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;
@@ -87,6 +85,9 @@ class Painter extends Frame_1.Frame {
             let lastCachedLayer;
             for (let i = 0; i < this.layers.length; i++) {
                 const layer = this.layers[i];
+                if (layer === undefined) {
+                    continue;
+                }
                 if (layer.cairoCache !== undefined &&
                     layer.surfaceCache !== undefined &&
                     surface === undefined &&
@@ -120,7 +121,7 @@ class Painter extends Frame_1.Frame {
         }
         for (let i = layerIdx; i < this.layers.length; i++) {
             const currentLayer = this.layers[i];
-            if (currentLayer.surfaceCache !== undefined && currentLayer.cairoCache !== undefined) {
+            if (currentLayer?.surfaceCache !== undefined && currentLayer.cairoCache !== undefined) {
                 await this.cleanupSurface(currentLayer.surfaceCache, currentLayer.cairoCache);
                 currentLayer.surfaceCache = undefined;
                 currentLayer.cairoCache = undefined;

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;
@@ -17,34 +18,30 @@ class ResourceManager {
         this.fontFileNames[moniker] = process.env.INSTALL_PATH + '/fonts/' + fileName;
     }
     async image(moniker) {
-        if (moniker in this.images) {
+        if (this.images[moniker] !== undefined) {
             return this.images[moniker];
         }
-        else if (moniker in this.imgFileNames) {
+        if (this.imgFileNames[moniker] !== undefined) {
             const imgData = await fs.readFile(this.imgFileNames[moniker]);
             this.images[moniker] = await this.co.uploadImageData(imgData);
             return this.images[moniker];
         }
-        else {
-            throw new Error('Error! Unknown image requested!');
-        }
+        throw new Error('Error! Unknown image requested!');
     }
     async font(moniker) {
-        if (moniker in this.fonts) {
+        if (this.fonts[moniker] !== undefined) {
             return this.fonts[moniker];
         }
-        else if (moniker in this.fontFileNames) {
+        if (this.fontFileNames[moniker] !== undefined) {
             const fontData = await fs.readFile(this.fontFileNames[moniker]);
             this.fonts[moniker] = await this.co.uploadFontData(fontData);
             return this.fonts[moniker];
         }
-        else {
-            throw new Error('Error! Unknown font requested!');
-        }
+        throw new Error('Error! Unknown font requested!');
     }
     clear() {
         this.images = {};
         this.fonts = {};
     }
 }
-exports.default = ResourceManager;
+exports.ResourceManager = ResourceManager;

package/cjs/CamScripterAPI.d.ts

@@ -1,19 +1,36 @@
-import { IClient } from './internal/common';
-import { CamScripterOptions, TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
-import { TNetworkCamera } from './types/common';
-export declare class CamOverlayAPI {
-    private client;
-    constructor(options?: CamScripterOptions | IClient);
-    checkCameraTime(): Promise<boolean>;
-    getStorageInfo(): Promise<TStorage>;
-    getNetworkCameraList(): Promise<TNetworkCamera[]>;
-    getPackageList(): Promise<TPackageInfoList>;
-    installPackages(formData: FormData, storage: TStorageType): Promise<void>;
-    uninstallPackage(packageId: string): Promise<void>;
-    importSettings(packageId: string, formData: FormData): Promise<void>;
-    exportSettings(packageId: string, formData: FormData): Promise<void>;
-    getNodejsStatus(): Promise<TNodeState>;
-    installNodejs(storage: TStorageType): Promise<void>;
+import { IClient, TResponse } from './internal/types';
+import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
+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(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, options?: THttpRequestOptions): Promise<{
+        status: number;
+        message: string;
+    }>;
+    importSettings(packageId: string, formData: FormData, options?: THttpRequestOptions): Promise<{
+        status: number;
+        message: string;
+    }>;
+    exportSettings(packageId: string, formData: FormData, options?: THttpRequestOptions): Promise<{
+        status: number;
+        message: string;
+    }>;
+    getNodejsStatus(options?: THttpRequestOptions): Promise<TNodeState>;
+    installNodejs(storage: TStorageType, options?: THttpRequestOptions): Promise<{
+        status: number;
+        message: string;
+    }>;
     private get;
     private post;
+    private getAgent;
 }

package/cjs/CamScripterAPI.js

@@ -1,70 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamOverlayAPI = void 0;
-const common_1 = require("./internal/common");
-const DefaultClient_1 = require("./node/DefaultClient");
+exports.CamScripterAPI = void 0;
+const ProxyClient_1 = require("./internal/ProxyClient");
+const utils_1 = require("./internal/utils");
 const CamScripterAPI_1 = require("./types/CamScripterAPI");
-const common_2 = require("./types/common");
-class CamOverlayAPI {
+const common_1 = require("./types/common");
+const BASE_PATH = '/local/camscripter';
+class CamScripterAPI {
     client;
-    constructor(options = {}) {
-        if ((0, common_1.isClient)(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient_1.DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
     }
-    async checkCameraTime() {
-        return (await this.get('/local/camscripter/camera_time.cgi')).state;
+    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
+    async checkCameraTime(options) {
+        const data = await this.get(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return CamScripterAPI_1.cameraTimeResponseSchema.parse(data).state;
     }
-    async getStorageInfo() {
-        const data = await this.get(`/local/camscripter/package/get_storage.cgi`);
-        return CamScripterAPI_1.storageSchema.parse(data);
+    async getNetworkCameraList(options) {
+        const data = await this.get(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return common_1.networkCameraListSchema.parse(data.camera_list);
     }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camscripter/network_camera_list.cgi');
-        return common_2.networkCameraListSchema.parse(response.camera_list);
+    async getStorageInfo(options) {
+        const data = await this.get(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
+        return CamScripterAPI_1.storageSchema.parse(data);
     }
-    async getPackageList() {
-        const data = await this.get('/local/camscripter/package/list.cgi');
+    async getPackageList(options) {
+        const data = await this.get(`${BASE_PATH}/package/list.cgi`, undefined, options);
         return CamScripterAPI_1.packageInfoListSchema.parse(data);
     }
-    async installPackages(formData, storage) {
-        await this.post(`/local/camscripter/package/install.cgi?storage=${storage}`, formData);
+    async installPackages(formData, storage, options) {
+        const data = await this.post(`${BASE_PATH}/package/install.cgi?storage=${storage}`, formData, undefined, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async uninstallPackage(packageId) {
-        await this.get(`/local/camscripter/package/remove.cgi?package_name=${packageId}`);
+    async uninstallPackage(packageId, options) {
+        const data = await this.get(`${BASE_PATH}/package/remove.cgi?package_name=${packageId}`, undefined, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async importSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData);
+    async importSettings(packageId, formData, options) {
+        const data = await this.post(`${BASE_PATH}/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData, undefined, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async exportSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=EXPORT&package_name=${packageId}`, formData);
+    async exportSettings(packageId, formData, options) {
+        const data = await this.post(`${BASE_PATH}/package/data.cgi?action=EXPORT&package_name=${packageId}`, formData, undefined, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async getNodejsStatus() {
-        return (await this.get('/local/camscripter/diagnostics.cgi')).node_state;
+    async getNodejsStatus(options) {
+        const data = await this.get(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
+        return CamScripterAPI_1.nodeStateSchema.parse(data);
     }
-    async installNodejs(storage) {
-        await this.get(`/local/camscripter/node_update.cgi?storage=${storage}`);
+    async installNodejs(storage, options) {
+        const data = await this.get(`${BASE_PATH}/node_update.cgi?storage=${storage}`, undefined, options);
+        return CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async get(path, parameters, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
-    async post(path, data, params) {
-        const res = await this.client.post(path, data, params);
+    async post(path, data, parameters, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({ path, data, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
+    getAgent(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
 }
-exports.CamOverlayAPI = CamOverlayAPI;
+exports.CamScripterAPI = CamScripterAPI;

package/cjs/CamScripterAPICameraEventsGenerator.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import * as EventEmitter from 'events';
-import { WsOptions } from './internal/common';
+import { WsOptions } from './internal/types';
 export type CamScripterOptions = WsOptions;
 export type TDeclaration = {
     type?: '' | 'SOURCE' | 'DATA';

package/cjs/CamScripterAPICameraEventsGenerator.js

@@ -91,10 +91,10 @@ class CamScripterAPICameraEventsGenerator extends EventEmitter {
         }
         if (dataJSON.call_id !== undefined) {
             if (errorResponse !== undefined) {
-                this.sendMessages[dataJSON.call_id].reject(new Error(errorResponse.error));
+                this.sendMessages[dataJSON.call_id]?.reject(new Error(errorResponse.error));
             }
             else {
-                this.sendMessages[dataJSON.call_id].resolve(dataJSON);
+                this.sendMessages[dataJSON.call_id]?.resolve(dataJSON);
             }
             delete this.sendMessages[dataJSON.call_id];
         }
@@ -127,6 +127,9 @@ class CamScripterAPICameraEventsGenerator extends EventEmitter {
             const now = Date.now();
             for (const callId in this.sendMessages) {
                 const msg = this.sendMessages[callId];
+                if (!msg) {
+                    continue;
+                }
                 if (now - msg.sentTimestamp > 10000) {
                     reconnect = true;
                     msg.reject(new Error('Message timeout'));
@@ -150,7 +153,7 @@ class CamScripterAPICameraEventsGenerator extends EventEmitter {
     }
     reportClose() {
         for (const callId in this.sendMessages) {
-            this.sendMessages[callId].reject(new Error('Connection lost'));
+            this.sendMessages[callId]?.reject(new Error('Connection lost'));
         }
         this.sendMessages = {};
         this.emit('close');

package/cjs/CamStreamerAPI.d.ts

@@ -1,16 +1,18 @@
-import { IClient } from './internal/common';
-import { CamStreamerAPIOptions, TStreamAttributes, TStreamList } from './types/CamStreamerAPI';
-export declare class CamStreamerAPI {
-    private client;
-    constructor(options?: CamStreamerAPIOptions | IClient);
-    getStreamList(): Promise<TStreamList>;
-    getStream(streamID: string): Promise<TStreamAttributes>;
-    getStreamParameter(streamID: string, paramName: string): Promise<string>;
-    setStream(streamID: string, params: Partial<TStreamAttributes>): Promise<void>;
-    setStreamParameter(streamID: string, paramName: string, value: string): Promise<void>;
-    isStreaming(streamID: string): Promise<boolean>;
-    deleteStream(streamID: string): Promise<void>;
-    wsAutoratization(): Promise<string>;
-    getUtcTime(): Promise<number>;
+import { IClient, TResponse } from './internal/types';
+import { TStreamAttributes, TStreamList } from './types/CamStreamerAPI';
+import { THttpRequestOptions } from './types/common';
+export declare class CamStreamerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    client: Client;
+    constructor(client: Client);
+    getStreamList(options?: THttpRequestOptions): Promise<TStreamList>;
+    getStream(streamId: string, options?: THttpRequestOptions): Promise<TStreamAttributes>;
+    getStreamParameter(streamId: string, paramName: string, options?: THttpRequestOptions): Promise<string>;
+    setStream(streamId: string, params: Partial<TStreamAttributes>, options?: THttpRequestOptions): Promise<void>;
+    setStreamParameter(streamId: string, paramName: string, value: string, options?: THttpRequestOptions): Promise<void>;
+    isStreaming(streamId: string, options?: THttpRequestOptions): Promise<boolean>;
+    deleteStream(streamId: string, options?: THttpRequestOptions): Promise<void>;
+    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getUtcTime(options?: THttpRequestOptions): Promise<number>;
     private get;
+    private getAgent;
 }

package/cjs/CamStreamerAPI.js

@@ -1,65 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamStreamerAPI = void 0;
-const common_1 = require("./internal/common");
-const DefaultClient_1 = require("./node/DefaultClient");
+const ProxyClient_1 = require("./internal/ProxyClient");
+const utils_1 = require("./internal/utils");
 const CamStreamerAPI_1 = require("./types/CamStreamerAPI");
+const BASE_PATH = '/local/camstreamer';
 class CamStreamerAPI {
     client;
-    constructor(options = {}) {
-        if ((0, common_1.isClient)(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient_1.DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
     }
-    async getStreamList() {
-        const streamListRes = await this.get('/local/camstreamer/stream/list.cgi');
+    async getStreamList(options) {
+        const streamListRes = await this.get(`${BASE_PATH}/stream/list.cgi`, undefined, options);
         return CamStreamerAPI_1.streamListSchema.parse(streamListRes.data);
     }
-    async getStream(streamID) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
+    async getStream(streamId, options) {
+        const stream = await this.get(`${BASE_PATH}/stream/get.cgi?stream_id=${streamId}`, undefined, options);
         return CamStreamerAPI_1.streamAttributesSchema.parse(stream.data);
     }
-    async getStreamParameter(streamID, paramName) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
+    async getStreamParameter(streamId, paramName, options) {
+        const stream = await this.get(`${BASE_PATH}/stream/get.cgi?stream_id=${streamId}`, undefined, options);
         return stream.data[paramName];
     }
-    async setStream(streamID, params) {
+    async setStream(streamId, params, options) {
         const { streamDelay, startTime, stopTime, ...rest } = params;
-        await this.get('/local/camstreamer/stream/set.cgi', {
-            stream_id: streamID,
+        await this.get(`${BASE_PATH}/stream/set.cgi`, {
+            stream_id: streamId,
             streamDelay: streamDelay ?? '',
             startTime: startTime ?? 'null',
             stopTime: stopTime ?? 'null',
             ...rest,
-        });
+        }, options);
     }
-    async setStreamParameter(streamID, paramName, value) {
-        await this.get(`/local/camstreamer/stream/set.cgi?stream_id=${streamID}&${paramName}=${value}`);
+    async setStreamParameter(streamId, paramName, value, options) {
+        await this.get(`${BASE_PATH}/stream/set.cgi?stream_id=${streamId}&${paramName}=${value}`, undefined, options);
     }
-    async isStreaming(streamID) {
-        const response = await this.get(`/local/camstreamer/get_streamstat.cgi?stream_id=${streamID}`);
+    async isStreaming(streamId, options) {
+        const response = await this.get(`${BASE_PATH}/get_streamstat.cgi?stream_id=${streamId}`, undefined, options);
         return response.data.is_streaming === 1;
     }
-    async deleteStream(streamID) {
-        await this.get('/local/camstreamer/stream/remove.cgi', { stream_id: streamID });
+    async deleteStream(streamId, options) {
+        await this.get(`${BASE_PATH}/stream/remove.cgi`, { stream_id: streamId }, options);
     }
-    wsAutoratization() {
-        return this.get('/local/camstreamer/ws_authorization.cgi');
+    wsAuthorization(options) {
+        return this.get(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
     }
-    async getUtcTime() {
-        return await this.get('/local/camstreamer/get_utc_time.cgi');
+    async getUtcTime(options) {
+        return await this.get(`${BASE_PATH}/get_utc_time.cgi`, undefined, options);
     }
-    async get(path, parameters) {
-        const res = await this.client.get(path, parameters);
+    async get(path, parameters, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
+    getAgent(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
 }
 exports.CamStreamerAPI = CamStreamerAPI;