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

package/cjs/CamScripterAPI.js

@@ -1,58 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamScripterAPI = exports.BASE_URL = void 0;
+exports.CamScripterAPI = void 0;
+const ProxyClient_1 = require("./internal/ProxyClient");
 const utils_1 = require("./internal/utils");
 const CamScripterAPI_1 = require("./types/CamScripterAPI");
 const common_1 = require("./types/common");
-exports.BASE_URL = '/local/camscripter';
+const BASE_PATH = '/local/camscripter';
 class CamScripterAPI {
     client;
     constructor(client) {
         this.client = client;
     }
-    static getProxyUrlPath = () => `${exports.BASE_URL}/proxy.cgi`;
-    async checkCameraTime() {
-        const data = await this.get(`${exports.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 CamScripterAPI_1.cameraTimeResponseSchema.parse(data).state;
     }
-    async getNetworkCameraList() {
-        const data = await this.get(`${exports.BASE_URL}/network_camera_list.cgi`);
+    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 getStorageInfo() {
-        const data = await this.get(`${exports.BASE_URL}/package/get_storage.cgi`);
+    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(`${exports.BASE_URL}/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) {
-        const data = await this.post(`${exports.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 CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async uninstallPackage(packageId) {
-        const data = await this.get(`${exports.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 CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async importSettings(packageId, formData) {
-        const data = await this.post(`${exports.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 CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async exportSettings(packageId, formData) {
-        const data = await this.post(`${exports.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 CamScripterAPI_1.camscripterApiResponseSchema.parse(data);
     }
-    async getNodejsStatus() {
-        const data = await this.get(`${exports.BASE_URL}/diagnostics.cgi`);
+    async getNodejsStatus(options) {
+        const data = await this.get(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
         return CamScripterAPI_1.nodeStateSchema.parse(data);
     }
-    async installNodejs(storage) {
-        const data = await this.get(`${exports.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 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();
         }
@@ -60,8 +62,9 @@ class CamScripterAPI {
             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();
         }
@@ -69,5 +72,8 @@ class CamScripterAPI {
             throw new Error(await (0, utils_1.responseStringify)(res));
         }
     }
+    getAgent(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
 }
 exports.CamScripterAPI = CamScripterAPI;

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

@@ -1,53 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamStreamerAPI = void 0;
+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(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();
         }
@@ -55,5 +58,8 @@ class CamStreamerAPI {
             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;

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

@@ -9,7 +9,8 @@ const common_1 = require("./types/common");
 const VapixAPI_1 = require("./VapixAPI");
 const versionCompare_1 = require("./internal/versionCompare");
 const constants_1 = require("./internal/constants");
-const baseUrl = '/local/camswitcher/api';
+const ProxyClient_1 = require("./internal/ProxyClient");
+const BASE_PATH = '/local/camswitcher/api';
 class CamSwitcherAPI {
     client;
     CustomFormData;
@@ -17,111 +18,117 @@ class CamSwitcherAPI {
     constructor(client, CustomFormData = FormData) {
         this.client = client;
         this.CustomFormData = CustomFormData;
-        this.vapixAgent = new VapixAPI_1.VapixAPI(client, () => '');
+        this.vapixAgent = new VapixAPI_1.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 zod_1.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 common_1.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 zod_1.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 CamSwitcherAPI_1.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 zod_1.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 CamSwitcherAPI_1.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 CamSwitcherAPI_1.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 CamSwitcherAPI_1.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 CamSwitcherAPI_1.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 CamSwitcherAPI_1.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 CamSwitcherAPI_1.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 CamSwitcherAPI_1.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 errors_1.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 CamSwitcherAPI_1.clipListSchema.parse(data).clip_list;
     }
-    setCamSwitchOptions(data, cameraFWVersion) {
+    setCamSwitchOptions(data, cameraFWVersion, options) {
         const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
         const saveData = {
             video: {
@@ -139,9 +146,9 @@ 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 ((0, utils_1.isClip)(settings.source)) {
@@ -157,9 +164,9 @@ 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 ?? '',
@@ -168,19 +175,19 @@ 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 ((0, utils_1.isNullish)(saveData.video)) {
             return saveData;
         }
@@ -205,12 +212,12 @@ 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;
@@ -222,8 +229,8 @@ 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,
@@ -234,13 +241,14 @@ 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;
@@ -249,8 +257,9 @@ class CamSwitcherAPI {
             throw new Error(await (0, utils_1.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';
@@ -259,13 +268,13 @@ class CamSwitcherAPI {
             throw new Error(await (0, utils_1.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] === '') {
@@ -281,6 +290,9 @@ class CamSwitcherAPI {
         }
         throw new Error("Error: no parametr '" + paramName + "' was found");
     }
+    getAgent(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
 }
 exports.CamSwitcherAPI = CamSwitcherAPI;
 const CSW_PARAM_NAMES = {