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

package/esm/CamScripterAPI.js

@@ -1,55 +1,57 @@
+import { ProxyClient } from './internal/ProxyClient';
 import { responseStringify } from './internal/utils';
 import { cameraTimeResponseSchema, camscripterApiResponseSchema, nodeStateSchema, packageInfoListSchema, storageSchema, } from './types/CamScripterAPI';
 import { networkCameraListSchema } from './types/common';
-export const BASE_URL = '/local/camscripter';
+const BASE_PATH = '/local/camscripter';
 export class CamScripterAPI {
     client;
     constructor(client) {
         this.client = client;
     }
-    static getProxyUrlPath = () => `${BASE_URL}/proxy.cgi`;
-    async checkCameraTime() {
-        const data = await this.get(`${BASE_URL}/camera_time.cgi`);
+    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
+    async checkCameraTime(options) {
+        const data = await this.get(`${BASE_PATH}/camera_time.cgi`, undefined, options);
         return cameraTimeResponseSchema.parse(data).state;
     }
-    async getNetworkCameraList() {
-        const data = await this.get(`${BASE_URL}/network_camera_list.cgi`);
+    async getNetworkCameraList(options) {
+        const data = await this.get(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
         return networkCameraListSchema.parse(data.camera_list);
     }
-    async getStorageInfo() {
-        const data = await this.get(`${BASE_URL}/package/get_storage.cgi`);
+    async getStorageInfo(options) {
+        const data = await this.get(`${BASE_PATH}/package/get_storage.cgi`, undefined, options);
         return storageSchema.parse(data);
     }
-    async getPackageList() {
-        const data = await this.get(`${BASE_URL}/package/list.cgi`);
+    async getPackageList(options) {
+        const data = await this.get(`${BASE_PATH}/package/list.cgi`, undefined, options);
         return packageInfoListSchema.parse(data);
     }
-    async installPackages(formData, storage) {
-        const data = await this.post(`${BASE_URL}/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 camscripterApiResponseSchema.parse(data);
     }
-    async uninstallPackage(packageId) {
-        const data = await this.get(`${BASE_URL}/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 camscripterApiResponseSchema.parse(data);
     }
-    async importSettings(packageId, formData) {
-        const data = await this.post(`${BASE_URL}/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 camscripterApiResponseSchema.parse(data);
     }
-    async exportSettings(packageId, formData) {
-        const data = await this.post(`${BASE_URL}/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 camscripterApiResponseSchema.parse(data);
     }
-    async getNodejsStatus() {
-        const data = await this.get(`${BASE_URL}/diagnostics.cgi`);
+    async getNodejsStatus(options) {
+        const data = await this.get(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
         return nodeStateSchema.parse(data);
     }
-    async installNodejs(storage) {
-        const data = await this.get(`${BASE_URL}/node_update.cgi?storage=${storage}`);
+    async installNodejs(storage, options) {
+        const data = await this.get(`${BASE_PATH}/node_update.cgi?storage=${storage}`, undefined, options);
         return 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();
         }
@@ -57,8 +59,9 @@ export class CamScripterAPI {
             throw new Error(await 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();
         }
@@ -66,4 +69,7 @@ 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,16 +1,18 @@
 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(): 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>;
+    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/esm/CamStreamerAPI.js

@@ -1,50 +1,53 @@
+import { ProxyClient } from './internal/ProxyClient';
 import { responseStringify } from './internal/utils';
 import { streamAttributesSchema, streamListSchema } from './types/CamStreamerAPI';
+const BASE_PATH = '/local/camstreamer';
 export class CamStreamerAPI {
     client;
     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 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 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();
         }
@@ -52,4 +55,7 @@ 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,6 @@
 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, TNetworkCamera, TStorageType } from './types/common';
+import { TAudioChannel, THttpRequestOptions, TNetworkCamera, TStorageType } from './types/common';
 export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     client: Client;
     private CustomFormData;
@@ -12,41 +12,42 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<
     static getProxyUrlPath: () => string;
     static getWsEventsUrlPath: () => string;
     static getClipPreviewUrlPath: (id: string, storage: TStorageType) => string;
-    generateSilence(sampleRate: number, channels: TAudioChannel): Promise<void>;
-    checkCameraTime(): Promise<boolean>;
-    getIpListFromNetworkCheck(): Promise<TNetworkCamera[]>;
-    getMaxFps(source: number): Promise<number>;
-    getStorageInfo(): Promise<TStorageInfo[]>;
-    wsAuthorization(): Promise<string>;
-    getOutputInfo(): Promise<TOutputInfo>;
-    getAudioPushInfo(): Promise<TAudioPushInfo>;
-    getStreamSaveList(): Promise<TStreamSaveLoadList>;
-    getClipSaveList(): Promise<TClipSaveLoadList>;
-    getPlaylistSaveList(): Promise<TPlaylistSaveLoadList>;
-    getTrackerSaveList(): Promise<TrackerSaveLoadList>;
-    setStreamSaveList(data: TStreamSaveList): Promise<boolean>;
-    setClipSaveList(data: TClipSaveList): Promise<boolean>;
-    setPlaylistSaveList(data: TPlaylistSaveList): Promise<boolean>;
-    setTrackerSaveList(data: TTrackerSaveList): Promise<boolean>;
-    playlistSwitch(playlistName: string): Promise<void>;
-    playlistQueuePush(playlistName: string): Promise<void>;
-    playlistQueueClear(): Promise<void>;
-    playlistQueueList(): Promise<string[]>;
-    playlistQueuePlayNext(): Promise<void>;
-    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string): Promise<void>;
-    removeClip(id: string, storage: TStorageType): Promise<any>;
-    getClipList(): Promise<TClipList>;
-    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string): Promise<boolean>;
-    setGlobalAudioSettings(settings: TGlobalAudioSettings): Promise<boolean>;
-    setSecondaryAudioSettings(settings: TSecondaryAudioSettings): Promise<boolean>;
-    setDefaultPlaylist(id: string): Promise<boolean>;
-    setPermanentRtspUrlToken(token: string): Promise<boolean>;
-    getCamSwitchOptions(): Promise<Partial<TCameraOptions>>;
-    getGlobalAudioSettings(): Promise<TGlobalAudioSettings>;
-    getSecondaryAudioSettings(): Promise<TSecondaryAudioSettings>;
-    getPermanentRtspUrlToken(): Promise<string>;
+    generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
+    getMaxFps(source: number, options?: THttpRequestOptions): Promise<number>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<TStorageInfo[]>;
+    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getOutputInfo(options?: THttpRequestOptions): Promise<TOutputInfo>;
+    getAudioPushInfo(options?: THttpRequestOptions): Promise<TAudioPushInfo>;
+    getStreamSaveList(options?: THttpRequestOptions): Promise<TStreamSaveLoadList>;
+    getClipSaveList(options?: THttpRequestOptions): Promise<TClipSaveLoadList>;
+    getPlaylistSaveList(options?: THttpRequestOptions): Promise<TPlaylistSaveLoadList>;
+    getTrackerSaveList(options?: THttpRequestOptions): Promise<TrackerSaveLoadList>;
+    setStreamSaveList(data: TStreamSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    setClipSaveList(data: TClipSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    setPlaylistSaveList(data: TPlaylistSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    setTrackerSaveList(data: TTrackerSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    playlistSwitch(playlistName: string, options?: THttpRequestOptions): Promise<void>;
+    playlistQueuePush(playlistName: string, options?: THttpRequestOptions): Promise<void>;
+    playlistQueueClear(options?: THttpRequestOptions): Promise<void>;
+    playlistQueueList(options?: THttpRequestOptions): Promise<string[]>;
+    playlistQueuePlayNext(options?: THttpRequestOptions): Promise<void>;
+    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
+    removeClip(id: string, storage: TStorageType, options?: THttpRequestOptions): Promise<any>;
+    getClipList(options?: THttpRequestOptions): Promise<TClipList>;
+    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<boolean>;
+    setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<boolean>;
+    setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<boolean>;
+    setDefaultPlaylist(id: string, options?: THttpRequestOptions): Promise<boolean>;
+    setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<boolean>;
+    getCamSwitchOptions(options?: THttpRequestOptions): Promise<Partial<TCameraOptions>>;
+    getGlobalAudioSettings(options?: THttpRequestOptions): Promise<TGlobalAudioSettings>;
+    getSecondaryAudioSettings(options?: THttpRequestOptions): Promise<TSecondaryAudioSettings>;
+    getPermanentRtspUrlToken(options?: THttpRequestOptions): Promise<string>;
     private get;
     private set;
     private setParamFromCameraJSON;
     private getParamFromCameraAndJSONParse;
+    private getAgent;
 }

package/esm/CamSwitcherAPI.js

@@ -2,11 +2,12 @@ import { z } from 'zod';
 import { AddNewClipError } from './errors/errors';
 import { isClip, isNullish, responseStringify } from './internal/utils';
 import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, } from './types/CamSwitcherAPI';
-import { networkCameraListSchema } from './types/common';
+import { networkCameraListSchema, } from './types/common';
 import { VapixAPI } from './VapixAPI';
 import { isFirmwareVersionAtLeast } from './internal/versionCompare';
 import { FIRMWARE_WITH_BITRATE_MODES_SUPPORT } from './internal/constants';
-const baseUrl = '/local/camswitcher/api';
+import { ProxyClient } from './internal/ProxyClient';
+const BASE_PATH = '/local/camswitcher/api';
 export class CamSwitcherAPI {
     client;
     CustomFormData;
@@ -14,111 +15,117 @@ export class CamSwitcherAPI {
     constructor(client, CustomFormData = FormData) {
         this.client = client;
         this.CustomFormData = CustomFormData;
-        this.vapixAgent = new VapixAPI(client, () => '');
+        this.vapixAgent = new VapixAPI(client);
     }
-    static getProxyUrlPath = () => `${baseUrl}/proxy.cgi`;
+    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
     static getWsEventsUrlPath = () => `/local/camswitcher/events`;
-    static getClipPreviewUrlPath = (id, storage) => `${baseUrl}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
-    async generateSilence(sampleRate, channels) {
-        await this.client.get(`${baseUrl}/generate_silence.cgi`, {
-            sample_rate: sampleRate.toString(),
-            channels,
+    static getClipPreviewUrlPath = (id, storage) => `${BASE_PATH}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
+    async generateSilence(sampleRate, channels, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        await agent.get({
+            path: `${BASE_PATH}/generate_silence.cgi`,
+            parameters: {
+                sample_rate: sampleRate.toString(),
+                channels,
+            },
+            timeout: options?.timeout,
         });
     }
-    async checkCameraTime() {
-        const data = await this.get(`${baseUrl}/camera_time.cgi`);
+    async checkCameraTime(options) {
+        const data = await this.get(`${BASE_PATH}/camera_time.cgi`, undefined, options);
         return z.boolean().parse(data);
     }
-    async getIpListFromNetworkCheck() {
-        const data = await this.get(`${baseUrl}/network_camera_list.cgi`);
+    async getNetworkCameraList(options) {
+        const data = await this.get(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
         return networkCameraListSchema.parse(data);
     }
-    async getMaxFps(source) {
-        const data = await this.get(`${baseUrl}/get_max_framerate.cgi`, {
+    async getMaxFps(source, options) {
+        const data = await this.get(`${BASE_PATH}/get_max_framerate.cgi`, {
             video_source: source.toString(),
-        });
+        }, options);
         return z.number().parse(data);
     }
-    async getStorageInfo() {
-        const data = await this.get(`${baseUrl}/get_storage.cgi`);
+    async getStorageInfo(options) {
+        const data = await this.get(`${BASE_PATH}/get_storage.cgi`, undefined, options);
         return storageInfoListSchema.parse(data);
     }
-    async wsAuthorization() {
-        const data = await this.get(`${baseUrl}/ws_authorization.cgi`);
+    async wsAuthorization(options) {
+        const data = await this.get(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
         return z.string().parse(data);
     }
-    async getOutputInfo() {
-        const data = await this.get(`${baseUrl}/output_info.cgi`);
+    async getOutputInfo(options) {
+        const data = await this.get(`${BASE_PATH}/output_info.cgi`, undefined, options);
         return outputInfoSchema.parse(data);
     }
-    async getAudioPushInfo() {
-        const data = await this.get(`${baseUrl}/audio_push_info.cgi`);
+    async getAudioPushInfo(options) {
+        const data = await this.get(`${BASE_PATH}/audio_push_info.cgi`, undefined, options);
         return audioPushInfoSchema.parse(data);
     }
-    async getStreamSaveList() {
-        const data = await this.get(`${baseUrl}/streams.cgi`, { action: 'get' });
+    async getStreamSaveList(options) {
+        const data = await this.get(`${BASE_PATH}/streams.cgi`, { action: 'get' }, options);
         return streamSaveLoadSchema.parse(data);
     }
-    async getClipSaveList() {
-        const data = await this.get(`${baseUrl}/clips.cgi`, { action: 'get' });
+    async getClipSaveList(options) {
+        const data = await this.get(`${BASE_PATH}/clips.cgi`, { action: 'get' }, options);
         return clipSaveLoadSchema.parse(data);
     }
-    async getPlaylistSaveList() {
-        const data = await this.get(`${baseUrl}/playlists.cgi`, { action: 'get' });
+    async getPlaylistSaveList(options) {
+        const data = await this.get(`${BASE_PATH}/playlists.cgi`, { action: 'get' }, options);
         return playlistSaveLoadSchema.parse(data);
     }
-    async getTrackerSaveList() {
-        const data = await this.get(`${baseUrl}/trackers.cgi`, { action: 'get' });
+    async getTrackerSaveList(options) {
+        const data = await this.get(`${BASE_PATH}/trackers.cgi`, { action: 'get' }, options);
         return trackerSaveLoadSchema.parse(data);
     }
-    async setStreamSaveList(data) {
-        return await this.set(`${baseUrl}/streams.cgi`, data, { action: 'set' });
+    async setStreamSaveList(data, options) {
+        return await this.set(`${BASE_PATH}/streams.cgi`, data, { action: 'set' }, options);
     }
-    async setClipSaveList(data) {
-        return await this.set(`${baseUrl}/clips.cgi`, data, { action: 'set' });
+    async setClipSaveList(data, options) {
+        return await this.set(`${BASE_PATH}/clips.cgi`, data, { action: 'set' }, options);
     }
-    async setPlaylistSaveList(data) {
-        return await this.set(`${baseUrl}/playlists.cgi`, data, { action: 'set' });
+    async setPlaylistSaveList(data, options) {
+        return await this.set(`${BASE_PATH}/playlists.cgi`, data, { action: 'set' }, options);
     }
-    async setTrackerSaveList(data) {
-        return await this.set(`${baseUrl}/trackers.cgi`, data, { action: 'set' });
+    async setTrackerSaveList(data, options) {
+        return await this.set(`${BASE_PATH}/trackers.cgi`, data, { action: 'set' }, options);
     }
-    async playlistSwitch(playlistName) {
-        await this.get(`${baseUrl}/playlist_switch.cgi?playlist_name=${playlistName}`);
+    async playlistSwitch(playlistName, options) {
+        await this.get(`${BASE_PATH}/playlist_switch.cgi`, { playlist_name: playlistName }, options);
     }
-    async playlistQueuePush(playlistName) {
-        await this.get(`${baseUrl}/playlist_queue_push.cgi?playlist_name=${playlistName}`);
+    async playlistQueuePush(playlistName, options) {
+        await this.get(`${BASE_PATH}/playlist_queue_push.cgi`, { playlist_name: playlistName }, options);
     }
-    async playlistQueueClear() {
-        await this.get(`${baseUrl}/playlist_queue_clear.cgi`);
+    async playlistQueueClear(options) {
+        await this.get(`${BASE_PATH}/playlist_queue_clear.cgi`, undefined, options);
     }
-    async playlistQueueList() {
-        const data = await this.get(`${baseUrl}/playlist_queue_list.cgi`);
+    async playlistQueueList(options) {
+        const data = await this.get(`${BASE_PATH}/playlist_queue_list.cgi`, undefined, options);
         return playlistQueueSchema.parse(data).playlistQueueList;
     }
-    async playlistQueuePlayNext() {
-        await this.get(`${baseUrl}/playlist_queue_play_next.cgi`);
+    async playlistQueuePlayNext(options) {
+        await this.get(`${BASE_PATH}/playlist_queue_play_next.cgi`, undefined, options);
     }
-    async addNewClip(file, clipType, storage, id, fileName) {
+    async addNewClip(file, clipType, storage, id, fileName, options) {
+        const path = `${BASE_PATH}/clip_upload.cgi?storage=${storage}`;
         const formData = new this.CustomFormData();
         formData.append('clip_name', id);
         formData.append('clip_type', clipType);
         formData.append('file', file, fileName);
-        const path = `${baseUrl}/clip_upload.cgi?storage=${storage}`;
-        const res = await this.client.post(path, formData);
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({ path, data: formData, timeout: options?.timeout });
         const output = (await res.json());
         if (output.status !== 200) {
             throw new AddNewClipError(output.message);
         }
     }
-    removeClip(id, storage) {
-        return this.get(`${baseUrl}/clip_remove.cgi`, { clip_name: id, storage });
+    removeClip(id, storage, options) {
+        return this.get(`${BASE_PATH}/clip_remove.cgi`, { clip_name: id, storage }, options);
     }
-    async getClipList() {
-        const data = await this.get(`${baseUrl}/clip_list.cgi`);
+    async getClipList(options) {
+        const data = await this.get(`${BASE_PATH}/clip_list.cgi`, undefined, options);
         return clipListSchema.parse(data).clip_list;
     }
-    setCamSwitchOptions(data, cameraFWVersion) {
+    setCamSwitchOptions(data, cameraFWVersion, options) {
         const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
         const saveData = {
             video: {
@@ -136,9 +143,9 @@ export class CamSwitcherAPI {
             },
             keyboard: data.keyboard,
         };
-        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SETTINGS, saveData);
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SETTINGS, saveData, options);
     }
-    setGlobalAudioSettings(settings) {
+    setGlobalAudioSettings(settings, options) {
         let acceptedType = 'NONE';
         if (settings.type === 'source' && settings.source) {
             if (isClip(settings.source)) {
@@ -154,9 +161,9 @@ export class CamSwitcherAPI {
             clip_name: settings.source,
             storage: settings.storage,
         };
-        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.MASTER_AUDIO, data);
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.MASTER_AUDIO, data, options);
     }
-    setSecondaryAudioSettings(settings) {
+    setSecondaryAudioSettings(settings, options) {
         const data = {
             type: settings.type,
             stream_name: settings.streamName ?? '',
@@ -165,19 +172,19 @@ export class CamSwitcherAPI {
             secondary_audio_level: settings.secondaryAudioLevel,
             master_audio_level: settings.masterAudioLevel,
         };
-        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SECONDARY_AUDIO, data);
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SECONDARY_AUDIO, data, options);
     }
-    setDefaultPlaylist(id) {
+    setDefaultPlaylist(id, options) {
         const value = JSON.stringify({ default_playlist_id: id });
         return this.vapixAgent.setParameter({
             [CSW_PARAM_NAMES.DEFAULT_PLAYLIST]: value,
-        }, null);
+        }, options);
     }
-    setPermanentRtspUrlToken(token) {
-        return this.vapixAgent.setParameter({ [CSW_PARAM_NAMES.RTSP_TOKEN]: token }, null);
+    setPermanentRtspUrlToken(token, options) {
+        return this.vapixAgent.setParameter({ [CSW_PARAM_NAMES.RTSP_TOKEN]: token }, options);
     }
-    async getCamSwitchOptions() {
-        const saveData = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SETTINGS);
+    async getCamSwitchOptions(options) {
+        const saveData = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SETTINGS, options);
         if (isNullish(saveData.video)) {
             return saveData;
         }
@@ -202,12 +209,12 @@ export class CamSwitcherAPI {
             keyboard: saveData.keyboard,
         };
     }
-    async getGlobalAudioSettings() {
+    async getGlobalAudioSettings(options) {
         const settings = {
             type: 'fromSource',
             source: 'fromSource',
         };
-        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.MASTER_AUDIO);
+        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.MASTER_AUDIO, options);
         if (res.type === 'STREAM') {
             settings.type = 'source';
             settings.source = res.stream_name;
@@ -219,8 +226,8 @@ export class CamSwitcherAPI {
         }
         return settings;
     }
-    async getSecondaryAudioSettings() {
-        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SECONDARY_AUDIO);
+    async getSecondaryAudioSettings(options) {
+        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SECONDARY_AUDIO, options);
         const settings = {
             type: res.type ?? 'NONE',
             streamName: res.stream_name,
@@ -231,13 +238,14 @@ export class CamSwitcherAPI {
         };
         return settings;
     }
-    async getPermanentRtspUrlToken() {
+    async getPermanentRtspUrlToken(options) {
         const paramName = CSW_PARAM_NAMES.RTSP_TOKEN;
-        const res = await this.vapixAgent.getParameter([paramName], null);
+        const res = await this.vapixAgent.getParameter([paramName], options);
         return res[paramName] ?? '';
     }
-    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) {
             const d = (await res.json());
             return d.data;
@@ -246,8 +254,9 @@ export class CamSwitcherAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async set(path, data, parameters = {}) {
-        const res = await this.client.post(path, JSON.stringify(data), parameters);
+    async set(path, data, parameters, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({ path, data: JSON.stringify(data), parameters, timeout: options?.timeout });
         if (res.ok) {
             const parsed = await res.json();
             return parsed.message === 'OK';
@@ -256,13 +265,13 @@ export class CamSwitcherAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    setParamFromCameraJSON(paramName, data) {
+    setParamFromCameraJSON(paramName, data, options) {
         const params = {};
         params[paramName] = JSON.stringify(data);
-        return this.vapixAgent.setParameter(params, null);
+        return this.vapixAgent.setParameter(params, options);
     }
-    async getParamFromCameraAndJSONParse(paramName) {
-        const data = await this.vapixAgent.getParameter([paramName], null);
+    async getParamFromCameraAndJSONParse(paramName, options) {
+        const data = await this.vapixAgent.getParameter([paramName], options);
         if (data[paramName] !== undefined) {
             try {
                 if (data[paramName] === '') {
@@ -278,6 +287,9 @@ 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',