camstreamerlib 4.0.0-beta.30 → 4.0.0-beta.32

package/cjs/types/CamOverlayAPI/widgetCommonTypes.d.ts

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+export declare const allowedWidgetNames: {
+    readonly accuweather: "accuweather";
+    readonly infoticker: "infoticker";
+    readonly customGraphics: "customGraphics";
+    readonly ptzCompass: "ptzCompass";
+    readonly images: "images";
+    readonly ptz: "ptz";
+    readonly pip: "pip";
+    readonly screenSharing: "screenSharing";
+    readonly web_camera: "web_camera";
+};
+export declare const coordinateSystemSchema: z.ZodUnion<[z.ZodLiteral<"top_left">, z.ZodLiteral<"top">, z.ZodLiteral<"top_right">, z.ZodLiteral<"left">, z.ZodLiteral<"center">, z.ZodLiteral<"right">, z.ZodLiteral<"bottom_left">, z.ZodLiteral<"bottom">, z.ZodLiteral<"bottom_right">]>;
+export type TCoordinates = z.infer<typeof coordinateSystemSchema> | '';
+export declare const languageSchema: z.ZodUnion<[z.ZodLiteral<"en-us">, z.ZodLiteral<"fr-fr">, z.ZodLiteral<"ja-jp">, z.ZodLiteral<"pt-pt">, z.ZodLiteral<"es-es">, z.ZodLiteral<"de-de">, z.ZodLiteral<"ko-kr">, z.ZodLiteral<"zh-hk">, z.ZodLiteral<"zh-cn">, z.ZodLiteral<"nl-nl">, z.ZodLiteral<"cs-cz">, z.ZodLiteral<"ru-ru">, z.ZodLiteral<"sv-se">]>;
+export type TLanguage = z.infer<typeof languageSchema>;
+export declare const fontSchema: z.ZodUnion<[z.ZodLiteral<"classic">, z.ZodLiteral<"digital">, z.ZodType<string, z.ZodTypeDef, string>]>;
+export type TFont = z.infer<typeof fontSchema>;
+export declare const weatherUnitSchema: z.ZodUnion<[z.ZodLiteral<"Metric">, z.ZodLiteral<"Imperial">]>;
+export type TWeatherUnit = z.infer<typeof weatherUnitSchema>;
+export declare const widgetCommonSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    automationType: z.ZodUnion<[z.ZodLiteral<"time">, z.ZodLiteral<"manual">, z.ZodLiteral<"schedule">, z.ZodType<`input${number}`, z.ZodTypeDef, `input${number}`>]>;
+    invertInput: z.ZodOptional<z.ZodBoolean>;
+    cameraList: z.ZodArray<z.ZodNumber, "many">;
+    camera: z.ZodOptional<z.ZodNumber>;
+    schedule: z.ZodOptional<z.ZodString>;
+    customName: z.ZodString;
+    zIndex: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    camera?: number | undefined;
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    zIndex?: number | undefined;
+}, {
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    camera?: number | undefined;
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    zIndex?: number | undefined;
+}>;
+export declare const sharingSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    automationType: z.ZodUnion<[z.ZodLiteral<"time">, z.ZodLiteral<"manual">, z.ZodLiteral<"schedule">, z.ZodType<`input${number}`, z.ZodTypeDef, `input${number}`>]>;
+    invertInput: z.ZodOptional<z.ZodBoolean>;
+    cameraList: z.ZodArray<z.ZodNumber, "many">;
+    camera: z.ZodOptional<z.ZodNumber>;
+    schedule: z.ZodOptional<z.ZodString>;
+    customName: z.ZodString;
+    zIndex: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+} & {
+    pos_x: z.ZodNumber;
+    pos_y: z.ZodNumber;
+    coordSystem: z.ZodUnion<[z.ZodLiteral<"top_left">, z.ZodLiteral<"top">, z.ZodLiteral<"top_right">, z.ZodLiteral<"left">, z.ZodLiteral<"center">, z.ZodLiteral<"right">, z.ZodLiteral<"bottom_left">, z.ZodLiteral<"bottom">, z.ZodLiteral<"bottom_right">]>;
+    screenSize: z.ZodNumber;
+    fps: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    fps: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    pos_x: number;
+    pos_y: number;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    screenSize: number;
+    camera?: number | undefined;
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    zIndex?: number | undefined;
+}, {
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    fps: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    pos_x: number;
+    pos_y: number;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    screenSize: number;
+    camera?: number | undefined;
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    zIndex?: number | undefined;
+}>;
+export declare const overlaySchema: z.ZodObject<{
+    active: z.ZodBoolean;
+    coordSystem: z.ZodUnion<[z.ZodLiteral<"top_left">, z.ZodLiteral<"top">, z.ZodLiteral<"top_right">, z.ZodLiteral<"left">, z.ZodLiteral<"center">, z.ZodLiteral<"right">, z.ZodLiteral<"bottom_left">, z.ZodLiteral<"bottom">, z.ZodLiteral<"bottom_right">]>;
+    pos_x: z.ZodNumber;
+    pos_y: z.ZodNumber;
+    imgPath: z.ZodString;
+    imgName: z.ZodString;
+    duration: z.ZodNumber;
+    scale: z.ZodNumber;
+    fps: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    duration: number;
+    pos_x: number;
+    pos_y: number;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    active: boolean;
+    imgPath: string;
+    imgName: string;
+    scale: number;
+    fps?: number | undefined;
+}, {
+    duration: number;
+    pos_x: number;
+    pos_y: number;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    active: boolean;
+    imgPath: string;
+    imgName: string;
+    scale: number;
+    fps?: number | undefined;
+}>;

package/cjs/types/CamOverlayAPI/widgetCommonTypes.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overlaySchema = exports.sharingSchema = exports.widgetCommonSchema = exports.weatherUnitSchema = exports.fontSchema = exports.languageSchema = exports.coordinateSystemSchema = exports.allowedWidgetNames = void 0;
+const zod_1 = require("zod");
+exports.allowedWidgetNames = {
+    accuweather: 'accuweather',
+    infoticker: 'infoticker',
+    customGraphics: 'customGraphics',
+    ptzCompass: 'ptzCompass',
+    images: 'images',
+    ptz: 'ptz',
+    pip: 'pip',
+    screenSharing: 'screenSharing',
+    web_camera: 'web_camera',
+};
+exports.coordinateSystemSchema = zod_1.z.union([
+    zod_1.z.literal('top_left'),
+    zod_1.z.literal('top'),
+    zod_1.z.literal('top_right'),
+    zod_1.z.literal('left'),
+    zod_1.z.literal('center'),
+    zod_1.z.literal('right'),
+    zod_1.z.literal('bottom_left'),
+    zod_1.z.literal('bottom'),
+    zod_1.z.literal('bottom_right'),
+]);
+exports.languageSchema = zod_1.z.union([
+    zod_1.z.literal('en-us'),
+    zod_1.z.literal('fr-fr'),
+    zod_1.z.literal('ja-jp'),
+    zod_1.z.literal('pt-pt'),
+    zod_1.z.literal('es-es'),
+    zod_1.z.literal('de-de'),
+    zod_1.z.literal('ko-kr'),
+    zod_1.z.literal('zh-hk'),
+    zod_1.z.literal('zh-cn'),
+    zod_1.z.literal('nl-nl'),
+    zod_1.z.literal('cs-cz'),
+    zod_1.z.literal('ru-ru'),
+    zod_1.z.literal('sv-se'),
+]);
+exports.fontSchema = zod_1.z.union([
+    zod_1.z.literal('classic'),
+    zod_1.z.literal('digital'),
+    zod_1.z.custom((val) => {
+        return typeof val === 'string';
+    }),
+]);
+exports.weatherUnitSchema = zod_1.z.union([zod_1.z.literal('Metric'), zod_1.z.literal('Imperial')]);
+exports.widgetCommonSchema = zod_1.z.object({
+    id: zod_1.z.number().nonnegative(),
+    enabled: zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]),
+    automationType: zod_1.z.union([
+        zod_1.z.literal('time'),
+        zod_1.z.literal('manual'),
+        zod_1.z.literal('schedule'),
+        zod_1.z.custom((val) => {
+            return typeof val === 'string' ? /^input\d+$/.test(val) : false;
+        }),
+    ]),
+    invertInput: zod_1.z.boolean().optional(),
+    cameraList: zod_1.z.array(zod_1.z.number()),
+    camera: zod_1.z.number().nonnegative().optional(),
+    schedule: zod_1.z.string().optional(),
+    customName: zod_1.z.string(),
+    zIndex: zod_1.z.number().optional(),
+    width: zod_1.z.number().nonnegative(),
+    height: zod_1.z.number().nonnegative(),
+});
+exports.sharingSchema = exports.widgetCommonSchema.extend({
+    pos_x: zod_1.z.number().nonnegative(),
+    pos_y: zod_1.z.number().nonnegative(),
+    coordSystem: exports.coordinateSystemSchema,
+    screenSize: zod_1.z.number().positive(),
+    fps: zod_1.z.number(),
+});
+exports.overlaySchema = zod_1.z.object({
+    active: zod_1.z.boolean(),
+    coordSystem: exports.coordinateSystemSchema,
+    pos_x: zod_1.z.number(),
+    pos_y: zod_1.z.number(),
+    imgPath: zod_1.z.string(),
+    imgName: zod_1.z.string(),
+    duration: zod_1.z.number(),
+    scale: zod_1.z.number(),
+    fps: zod_1.z.number().optional(),
+});

package/cjs/types/CamStreamerAPI.d.ts

@@ -25,8 +25,8 @@ export declare const streamAttributesSchema: z.ZodObject<{
     stopTime: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     enabled: string;
-    active: string;
     schedule: string;
+    active: string;
     audioSource: string;
     avSyncMsec: string;
     internalVapixParameters: string;
@@ -47,8 +47,8 @@ export declare const streamAttributesSchema: z.ZodObject<{
     stopTime: string;
 }, {
     enabled: string;
-    active: string;
     schedule: string;
+    active: string;
     audioSource: string;
     avSyncMsec: string;
     internalVapixParameters: string;
@@ -93,8 +93,8 @@ export declare const streamListSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     stopTime: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     enabled: string;
-    active: string;
     schedule: string;
+    active: string;
     audioSource: string;
     avSyncMsec: string;
     internalVapixParameters: string;
@@ -115,8 +115,8 @@ export declare const streamListSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     stopTime: string;
 }, {
     enabled: string;
-    active: string;
     schedule: string;
+    active: string;
     audioSource: string;
     avSyncMsec: string;
     internalVapixParameters: string;

package/cjs/types/CamSwitcherAPI.d.ts

@@ -1,7 +1,5 @@
-import { HttpOptions } from '../internal/types';
 import { z } from 'zod';
 import { TH264Profile, TAudioChannelCount, TKeyboardShortcut } from './common';
-export type CamSwitcherAPIOptions = HttpOptions;
 declare const channelTypeSchema: z.ZodUnion<[z.ZodLiteral<"audio">, z.ZodLiteral<"video">, z.ZodLiteral<"av">]>;
 export type TChannelType = z.infer<typeof channelTypeSchema>;
 declare const playlistPlayTypeSchema: z.ZodUnion<[z.ZodLiteral<"PLAY_ALL">, z.ZodLiteral<"PLAY_ALL_LOOP">, z.ZodLiteral<"PLAY_ALL_SHUFFLED">, z.ZodLiteral<"PLAY_ALL_LOOP_SHUFFLED">, z.ZodLiteral<"PLAY_ONE_RANDOM">]>;

package/cjs/types/VapixAPI.d.ts

@@ -1,6 +1,4 @@
-import { HttpOptions } from '../internal/types';
 import { z } from 'zod';
-export type CameraVapixOptions = HttpOptions;
 export declare const applicationSchema: z.ZodObject<{
     Name: z.ZodString;
     NiceName: z.ZodString;

package/esm/CamOverlayAPI.d.ts

@@ -1,26 +1,16 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { IClient, TBlobResponse, TResponse } from './internal/types';
-import { THttpRequestOptions, TNetworkCamera } from './types/common';
-import { ImageType, TCoordinates, TFile, TFileList, TFileType, TStorage, TStorageDataList, TWidget } from './types/CamOverlayAPI/CamOverlayAPI';
-import { TField } from './types/CamOverlayAPI';
-export declare const allowedWidgetNames: {
-    readonly accuweather: "accuweather";
-    readonly infoticker: "infoticker";
-    readonly customGraphics: "customGraphics";
-    readonly ptzCompass: "ptzCompass";
-    readonly images: "images";
-    readonly ptz: "ptz";
-    readonly pip: "pip";
-    readonly screenSharing: "screenSharing";
-    readonly web_camera: "web_camera";
-};
+import { THttpRequestOptions, TProxyParams, TNetworkCamera } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+import { ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TStorage, TStorageDataList, TWidget } from './types/CamOverlayAPI';
 export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     private client;
     constructor(client: Client);
     static getBasePath: () => string;
     static getProxyPath: () => string;
     static getFilePreviewPath: (path: string) => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
@@ -48,5 +38,4 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<T
     private parseBlobResponse;
     private _postUrlEncoded;
     private _postJsonEncoded;
-    private getAgent;
 }

package/esm/CamOverlayAPI.js

@@ -3,18 +3,7 @@ import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
 import { z } from 'zod';
 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',
-};
+import { fileListSchema, ImageType, storageDataListSchema, widgetsSchema, WSResponseSchema, } from './types/CamOverlayAPI';
 const BASE_PATH = '/local/camoverlay/api';
 export class CamOverlayAPI {
     client;
@@ -24,6 +13,9 @@ export class CamOverlayAPI {
     static getBasePath = () => BASE_PATH;
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     static getFilePreviewPath = (path) => `${BASE_PATH}/image.cgi?path=${encodeURIComponent(path)}`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
     async checkCameraTime(options) {
         const response = await this._get({ path: `${BASE_PATH}/camera_time.cgi` }, options);
         return z.boolean().parse(response.state);
@@ -89,7 +81,7 @@ export class CamOverlayAPI {
         await this._post({ path: `${BASE_PATH}/enabled.cgi?id_${serviceId}=${enabled ? 1 : 0}`, data: '' }, options);
     }
     async isEnabled(serviceId, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(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());
@@ -186,7 +178,7 @@ export class CamOverlayAPI {
         if (contentType !== undefined && data) {
             headers = { 'Content-Type': contentType };
         }
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({
             path,
             data: data ?? '',
@@ -203,7 +195,7 @@ export class CamOverlayAPI {
         }
     }
     async _get(params, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({ ...params, timeout: options?.timeout });
         if (res.ok) {
             return (await res.json());
@@ -213,7 +205,7 @@ export class CamOverlayAPI {
         }
     }
     async _post(params, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({ ...params, timeout: options?.timeout });
         if (res.ok) {
             return (await res.json());
@@ -223,7 +215,7 @@ export class CamOverlayAPI {
         }
     }
     async _getBlob(params, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({ ...params, timeout: options?.timeout });
         if (res.ok) {
             return await this.parseBlobResponse(res);
@@ -249,7 +241,4 @@ export class CamOverlayAPI {
         const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
         return this._post({ path, data, parameters, headers: { ...baseHeaders, ...headers } }, options);
     }
-    getAgent(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
 }

package/esm/CamScripterAPI.d.ts

@@ -1,10 +1,12 @@
+import { ProxyClient } from './internal/ProxyClient';
 import { IClient, TResponse } from './internal/types';
 import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
-import { THttpRequestOptions, TNetworkCamera } from './types/common';
+import { THttpRequestOptions, TNetworkCamera, TProxyParams } from './types/common';
 export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     client: Client;
     constructor(client: Client);
     static getProxyUrlPath: () => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
     getStorageInfo(options?: THttpRequestOptions): Promise<TStorage>;
@@ -32,5 +34,4 @@ export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<
     }>;
     private get;
     private post;
-    private getAgent;
 }

package/esm/CamScripterAPI.js

@@ -9,6 +9,9 @@ export class CamScripterAPI {
         this.client = client;
     }
     static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
     async checkCameraTime(options) {
         const data = await this.get(`${BASE_PATH}/camera_time.cgi`, undefined, options);
         return cameraTimeResponseSchema.parse(data).state;
@@ -50,7 +53,7 @@ export class CamScripterAPI {
         return camscripterApiResponseSchema.parse(data);
     }
     async get(path, parameters, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
@@ -60,7 +63,7 @@ export class CamScripterAPI {
         }
     }
     async post(path, data, parameters, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({ path, data, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
@@ -69,7 +72,4 @@ export class CamScripterAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    getAgent(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
 }

package/esm/CamStreamerAPI.d.ts

@@ -1,9 +1,11 @@
+import { ProxyClient } from './internal/ProxyClient';
 import { IClient, TResponse } from './internal/types';
 import { TStreamAttributes, TStreamList } from './types/CamStreamerAPI';
-import { THttpRequestOptions } from './types/common';
+import { THttpRequestOptions, TProxyParams } from './types/common';
 export declare class CamStreamerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     client: Client;
     constructor(client: Client);
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     getStreamList(options?: THttpRequestOptions): Promise<TStreamList>;
     getStream(streamId: string, options?: THttpRequestOptions): Promise<TStreamAttributes>;
     getStreamParameter(streamId: string, paramName: string, options?: THttpRequestOptions): Promise<string>;
@@ -14,5 +16,4 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse> = IClient<
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
     getUtcTime(options?: THttpRequestOptions): Promise<number>;
     private get;
-    private getAgent;
 }

package/esm/CamStreamerAPI.js

@@ -7,6 +7,9 @@ export class CamStreamerAPI {
     constructor(client) {
         this.client = client;
     }
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
     async getStreamList(options) {
         const streamListRes = await this.get(`${BASE_PATH}/stream/list.cgi`, undefined, options);
         return streamListSchema.parse(streamListRes.data);
@@ -46,7 +49,7 @@ export class CamStreamerAPI {
         return await this.get(`${BASE_PATH}/get_utc_time.cgi`, undefined, options);
     }
     async get(path, parameters, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
@@ -55,7 +58,4 @@ export class CamStreamerAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    getAgent(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
 }

package/esm/CamSwitcherAPI.d.ts

@@ -1,6 +1,7 @@
 import { IClient, TResponse } from './internal/types';
 import { TAudioPushInfo, TOutputInfo, TStorageInfo, TStreamSaveList, TClipList, TStreamSaveLoadList, TClipSaveLoadList, TPlaylistSaveLoadList, TTrackerSaveList, TrackerSaveLoadList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
-import { TAudioChannel, THttpRequestOptions, TNetworkCamera, TStorageType } from './types/common';
+import { TAudioChannel, THttpRequestOptions, TNetworkCamera, TProxyParams, TStorageType } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
 export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     client: Client;
     private CustomFormData;
@@ -12,6 +13,7 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<
     static getProxyUrlPath: () => string;
     static getWsEventsUrlPath: () => string;
     static getClipPreviewUrlPath: (id: string, storage: TStorageType) => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
@@ -49,5 +51,4 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<
     private set;
     private setParamFromCameraJSON;
     private getParamFromCameraAndJSONParse;
-    private getAgent;
 }

package/esm/CamSwitcherAPI.js

@@ -20,8 +20,11 @@ export class CamSwitcherAPI {
     static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
     static getWsEventsUrlPath = () => `/local/camswitcher/events`;
     static getClipPreviewUrlPath = (id, storage) => `${BASE_PATH}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
     async generateSilence(sampleRate, channels, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         await agent.get({
             path: `${BASE_PATH}/generate_silence.cgi`,
             parameters: {
@@ -111,7 +114,7 @@ export class CamSwitcherAPI {
         formData.append('clip_name', id);
         formData.append('clip_type', clipType);
         formData.append('file', file, fileName);
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({ path, data: formData, timeout: options?.timeout });
         const output = (await res.json());
         if (output.status !== 200) {
@@ -244,7 +247,7 @@ export class CamSwitcherAPI {
         return res[paramName] ?? '';
     }
     async get(path, parameters, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             const d = (await res.json());
@@ -255,7 +258,7 @@ export class CamSwitcherAPI {
         }
     }
     async set(path, data, parameters, options) {
-        const agent = this.getAgent(options?.proxyParams);
+        const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({ path, data: JSON.stringify(data), parameters, timeout: options?.timeout });
         if (res.ok) {
             const parsed = await res.json();
@@ -287,9 +290,6 @@ export class CamSwitcherAPI {
         }
         throw new Error("Error: no parametr '" + paramName + "' was found");
     }
-    getAgent(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
 }
 const CSW_PARAM_NAMES = {
     SETTINGS: 'Camswitcher.Settings',

package/esm/PlaneTrackerAPI.d.ts

@@ -1,11 +1,13 @@
 import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
 import { ICAO, TApiUser, TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
-import { THttpRequestOptions } from './types/common';
+import { THttpRequestOptions, TProxyParams } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
 export declare class PlaneTrackerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     private client;
     private apiUser;
     constructor(client: Client, apiUser: TApiUser);
     static getProxyUrlPath: () => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     resetPtzCalibration: (options?: THttpRequestOptions) => Promise<TResponse>;
     resetFocusCalibration: (options?: THttpRequestOptions) => Promise<TResponse>;
@@ -38,5 +40,4 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse> = IClient
     private parseBlobResponse;
     private _postJsonEncoded;
     private _postUrlEncoded;
-    private getAgent;
 }