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

package/esm/PlaneTrackerAPI.d.ts

@@ -1,48 +1,42 @@
 import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
-import { TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
-export type TApiUser = {
-    userId: string;
-    userName: string;
-    userPriority: number;
-};
-type ICAO = string;
-export declare const BASE_URL = "/local/planetracker";
+import { ICAO, TApiUser, TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
+import { THttpRequestOptions } from './types/common';
 export declare class PlaneTrackerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     private client;
     private apiUser;
-    private _apiUserQuery;
     constructor(client: Client, apiUser: TApiUser);
     static getProxyUrlPath: () => string;
-    checkCameraTime(): Promise<boolean>;
-    fetchCameraSettings: () => Promise<any>;
-    setCameraSettings: (settingsJsonString: string) => Promise<TResponse>;
-    fetchServerSettings: () => Promise<any>;
-    fetchMapInfo: () => Promise<any>;
-    fetchFlightInfo: (icao: ICAO) => Promise<any>;
-    getZones: () => Promise<any>;
-    setZones: (zonesJsonString: string) => Promise<TResponse>;
-    getPriorityList: () => Promise<any>;
-    setPriorityList: (priorityListJsonString: string) => Promise<TResponse>;
-    getWhiteList: () => Promise<any>;
-    setWhiteList: (whiteListJsonString: string) => Promise<TResponse>;
-    getBlackList: () => Promise<any>;
-    setBlackList: (blackListJsonString: string) => Promise<TResponse>;
-    getTrackingMode: () => Promise<any>;
-    setTrackingMode: (modeJsonString: string) => Promise<TResponse>;
-    startTrackingPlane: (icao: ICAO) => Promise<TResponse>;
-    stopTrackingPlane: () => Promise<TResponse>;
-    goToCoordinates: (lat: number, lon: number, alt?: number) => Promise<TResponse>;
-    exportAppSettings: (dataType: TExportDataType) => Promise<TBlobResponse<Client>>;
-    importAppSettings: (dataType: TImportDataType, formData: FormData) => Promise<TResponse>;
-    resetPtzCalibration: () => Promise<TResponse>;
-    resetFocusCalibration: () => Promise<TResponse>;
-    checkGenetecConnection: (params: TParameters) => Promise<TResponse>;
-    getGenetecCameraList: (params: TParameters) => Promise<any>;
-    serverRunCheck: () => Promise<TResponse>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    resetPtzCalibration: (options?: THttpRequestOptions) => Promise<TResponse>;
+    resetFocusCalibration: (options?: THttpRequestOptions) => Promise<TResponse>;
+    serverRunCheck: (options?: THttpRequestOptions) => Promise<TResponse>;
+    getLiveViewAlias: (rtspUrl: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    fetchCameraSettings: (options?: THttpRequestOptions) => Promise<any>;
+    setCameraSettings: (settingsJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    fetchServerSettings: (options?: THttpRequestOptions) => Promise<any>;
+    exportAppSettings: (dataType: TExportDataType, options?: THttpRequestOptions) => Promise<TBlobResponse<Client>>;
+    importAppSettings: (dataType: TImportDataType, formData: FormData, options?: THttpRequestOptions) => Promise<TResponse>;
+    fetchFlightInfo: (icao: ICAO, options?: THttpRequestOptions) => Promise<any>;
+    getTrackingMode: (options?: THttpRequestOptions) => Promise<any>;
+    setTrackingMode: (modeJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    startTrackingPlane: (icao: ICAO, options?: THttpRequestOptions) => Promise<TResponse>;
+    stopTrackingPlane: (options?: THttpRequestOptions) => Promise<TResponse>;
+    getPriorityList: (options?: THttpRequestOptions) => Promise<any>;
+    setPriorityList: (priorityListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    getWhiteList: (options?: THttpRequestOptions) => Promise<any>;
+    setWhiteList: (whiteListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    getBlackList: (options?: THttpRequestOptions) => Promise<any>;
+    setBlackList: (blackListJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    fetchMapInfo: (options?: THttpRequestOptions) => Promise<any>;
+    getZones: (options?: THttpRequestOptions) => Promise<any>;
+    setZones: (zonesJsonString: string, options?: THttpRequestOptions) => Promise<TResponse>;
+    goToCoordinates: (lat: number, lon: number, alt?: number, options?: THttpRequestOptions) => Promise<TResponse>;
+    checkGenetecConnection: (params: TParameters, options?: THttpRequestOptions) => Promise<TResponse>;
+    getGenetecCameraList: (params: TParameters, options?: THttpRequestOptions) => Promise<any>;
     private _getJson;
     private _getBlob;
     private parseBlobResponse;
     private _postJsonEncoded;
     private _postUrlEncoded;
+    private getAgent;
 }
-export {};

package/esm/PlaneTrackerAPI.js

@@ -1,102 +1,145 @@
 import { z } from 'zod';
 import { paramToUrl, responseStringify } from './internal/utils';
 import { ParsingBlobError } from './errors/errors';
-export const BASE_URL = '/local/planetracker';
+import { ProxyClient } from './internal/ProxyClient';
+const BASE_PATH = '/local/planetracker';
 export class PlaneTrackerAPI {
     client;
     apiUser;
-    _apiUserQuery;
     constructor(client, apiUser) {
         this.client = client;
         this.apiUser = apiUser;
-        this._apiUserQuery = paramToUrl(this.apiUser);
     }
-    static getProxyUrlPath = () => `${BASE_URL}/proxy.cgi`;
-    async checkCameraTime() {
-        const response = await this._getJson(`${BASE_URL}/camera_time.cgi`);
+    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
+    async checkCameraTime(options) {
+        const response = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
         return z.boolean().parse(response.state);
     }
-    fetchCameraSettings = async () => {
-        return await this._getJson(`${BASE_URL}/package_camera_settings.cgi`, { action: 'get' });
+    resetPtzCalibration = async (options) => {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/resetPtzCalibration.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
     };
-    setCameraSettings = async (settingsJsonString) => {
-        return await this._postJsonEncoded(`${BASE_URL}/package_camera_settings.cgi`, settingsJsonString, {
-            action: 'set',
+    resetFocusCalibration = async (options) => {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/resetFocusCalibration.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
         });
     };
-    fetchServerSettings = async () => {
-        return await this._getJson(`${BASE_URL}/package_server_settings.cgi`, { action: 'get' });
+    serverRunCheck = async (options) => {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.get({ path: `${BASE_PATH}/package/serverRunCheck.cgi`, timeout: options?.timeout });
     };
-    fetchMapInfo = async () => {
-        return await this._getJson(`${BASE_URL}/package/getMapInfo.cgi`);
+    getLiveViewAlias = async (rtspUrl, options) => {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/getLiveViewAlias.cgi`,
+            parameters: { rtsp_url: rtspUrl },
+            timeout: options?.timeout,
+        });
     };
-    fetchFlightInfo = async (icao) => {
-        return await this._getJson(`${BASE_URL}/package/flightInfo.cgi`, { icao: encodeURIComponent(icao) });
+    fetchCameraSettings = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package_camera_settings.cgi`, { action: 'get' }, options);
     };
-    getZones = async () => {
-        return await this._getJson(`${BASE_URL}/package/getZones.cgi`);
+    setCameraSettings = async (settingsJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package_camera_settings.cgi`, settingsJsonString, {
+            action: 'set',
+        }, options);
     };
-    setZones = async (zonesJsonString) => {
-        return await this._postJsonEncoded(`${BASE_URL}/package/setZones.cgi?${this._apiUserQuery}`, zonesJsonString);
+    fetchServerSettings = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package_server_settings.cgi`, { action: 'get' }, options);
     };
-    getPriorityList = async () => {
-        return await this._getJson(`${BASE_URL}/package/getPriorityList.cgi`);
+    exportAppSettings = async (dataType, options) => {
+        return await this._getBlob(`${BASE_PATH}/package_data.cgi`, { action: 'EXPORT', dataType }, options);
     };
-    setPriorityList = async (priorityListJsonString) => {
-        return await this._postJsonEncoded(`${BASE_URL}/package/setPriorityList.cgi?${this._apiUserQuery}`, priorityListJsonString);
+    importAppSettings = async (dataType, formData, options) => {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.post({
+            path: `${BASE_PATH}/package_data.cgi`,
+            data: formData,
+            parameters: { action: 'IMPORT', dataType },
+            timeout: options?.timeout,
+        });
     };
-    getWhiteList = async () => {
-        return await this._getJson(`${BASE_URL}/package/getWhiteList.cgi`);
+    fetchFlightInfo = async (icao, options) => {
+        return await this._getJson(`${BASE_PATH}/package/flightInfo.cgi`, { icao: encodeURIComponent(icao) }, options);
     };
-    setWhiteList = async (whiteListJsonString) => {
-        return await this._postJsonEncoded(`${BASE_URL}/package/setWhiteList.cgi?${this._apiUserQuery}`, whiteListJsonString);
+    getTrackingMode = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getTrackingMode.cgi`, undefined, options);
     };
-    getBlackList = async () => {
-        return await this._getJson(`${BASE_URL}/package/getBlackList.cgi`);
+    setTrackingMode = async (modeJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setTrackingMode.cgi`, modeJsonString, this.apiUser, options);
     };
-    setBlackList = async (blackListJsonString) => {
-        return await this._postJsonEncoded(`${BASE_URL}/package/setBlackList.cgi?${this._apiUserQuery}`, blackListJsonString);
+    startTrackingPlane = async (icao, options) => {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/trackIcao.cgi`,
+            parameters: { icao, ...this.apiUser },
+            timeout: options?.timeout,
+        });
     };
-    getTrackingMode = async () => {
-        return await this._getJson(`${BASE_URL}/package/getTrackingMode.cgi`);
+    stopTrackingPlane = async (options) => {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/resetIcao.cgi`,
+            parameters: this.apiUser,
+            timeout: options?.timeout,
+        });
     };
-    setTrackingMode = async (modeJsonString) => {
-        return await this._postJsonEncoded(`${BASE_URL}/package/setTrackingMode.cgi?${this._apiUserQuery}`, modeJsonString);
+    getPriorityList = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getPriorityList.cgi`, undefined, options);
     };
-    startTrackingPlane = async (icao) => {
-        return await this.client.get(`${BASE_URL}/package/trackIcao.cgi?icao=${encodeURIComponent(icao)}&${this._apiUserQuery}`);
+    setPriorityList = async (priorityListJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setPriorityList.cgi`, priorityListJsonString, this.apiUser, options);
     };
-    stopTrackingPlane = async () => {
-        return await this.client.get(`${BASE_URL}/package/resetIcao.cgi?${this._apiUserQuery}`);
+    getWhiteList = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getWhiteList.cgi`, undefined, options);
     };
-    goToCoordinates = async (lat, lon, alt) => {
-        const url = `${BASE_URL}/package/goToCoordinates.cgi?lat=${lat}&lon=${lon}&${this._apiUserQuery}`;
-        return await this.client.get(`${url}${alt !== undefined ? `&alt=${alt}` : ''}`);
+    setWhiteList = async (whiteListJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setWhiteList.cgi`, whiteListJsonString, this.apiUser, options);
     };
-    exportAppSettings = async (dataType) => {
-        return await this._getBlob(`${BASE_URL}/package_data.cgi`, { action: 'EXPORT', dataType });
+    getBlackList = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getBlackList.cgi`, undefined, options);
     };
-    importAppSettings = async (dataType, formData) => {
-        return await this.client.post(`${BASE_URL}/package_data.cgi`, formData, { action: 'IMPORT', dataType });
+    setBlackList = async (blackListJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setBlackList.cgi`, blackListJsonString, this.apiUser, options);
     };
-    resetPtzCalibration = async () => {
-        return await this.client.get(`${BASE_URL}/package/resetPtzCalibration.cgi?${this._apiUserQuery}`);
+    fetchMapInfo = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getMapInfo.cgi`, undefined, options);
     };
-    resetFocusCalibration = async () => {
-        return await this.client.get(`${BASE_URL}/package/resetFocusCalibration.cgi?${this._apiUserQuery}`);
+    getZones = async (options) => {
+        return await this._getJson(`${BASE_PATH}/package/getZones.cgi`, undefined, options);
     };
-    checkGenetecConnection = async (params) => {
-        return await this._postUrlEncoded(`${BASE_URL}/package/checkGenetecConnection.cgi`, params);
+    setZones = async (zonesJsonString, options) => {
+        return await this._postJsonEncoded(`${BASE_PATH}/package/setZones.cgi`, zonesJsonString, this.apiUser, options);
     };
-    getGenetecCameraList = async (params) => {
-        const res = await this._postUrlEncoded(`${BASE_URL}/package/getGenetecCameraList.cgi`, params);
-        return await res.json();
+    goToCoordinates = async (lat, lon, alt, options) => {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.get({
+            path: `${BASE_PATH}/package/goToCoordinates.cgi`,
+            parameters: { lat, lon, alt, ...this.apiUser },
+            timeout: options?.timeout,
+        });
+    };
+    checkGenetecConnection = async (params, options) => {
+        return await this._postUrlEncoded(`${BASE_PATH}/package/checkGenetecConnection.cgi`, params, options);
     };
-    serverRunCheck = async () => {
-        return await this.client.get(`${BASE_URL}/package/serverRunCheck.cgi`);
+    getGenetecCameraList = async (params, options) => {
+        const res = await this._postUrlEncoded(`${BASE_PATH}/package/getGenetecCameraList.cgi`, params, options);
+        return await res.json();
     };
-    async _getJson(...args) {
-        const res = await this.client.get(...args);
+    async _getJson(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();
         }
@@ -104,8 +147,13 @@ export class PlaneTrackerAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async _getBlob(...args) {
-        const res = await this.client.get(...args);
+    async _getBlob(path, parameters, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({
+            path,
+            parameters,
+            timeout: options?.timeout,
+        });
         if (res.ok) {
             return await this.parseBlobResponse(res);
         }
@@ -121,10 +169,15 @@ export class PlaneTrackerAPI {
             throw new ParsingBlobError(err);
         }
     }
-    async _postJsonEncoded(...args) {
-        const [path, data, params, headers] = args;
-        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        const res = await this.client.post(path, data, params, { ...baseHeaders, ...headers });
+    async _postJsonEncoded(path, data, parameters, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data,
+            parameters,
+            headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
+            timeout: options?.timeout,
+        });
         if (res.ok) {
             return res;
         }
@@ -132,10 +185,15 @@ export class PlaneTrackerAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async _postUrlEncoded(path, params, headers) {
+    async _postUrlEncoded(path, params, options) {
         const data = paramToUrl(params);
-        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
-        const res = await this.client.post(path, data, {}, { ...baseHeaders, ...headers });
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data,
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            timeout: options?.timeout,
+        });
         if (res.ok) {
             return res;
         }
@@ -143,4 +201,7 @@ export class PlaneTrackerAPI {
             throw new Error(await responseStringify(res));
         }
     }
+    getAgent(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
 }

package/esm/VapixAPI.d.ts

@@ -1,26 +1,25 @@
 import { IClient, TParameters, TResponse } from './internal/types';
 import { TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice, TPortSetSchema, TPortSequenceStateSchema } from './types/VapixAPI';
-import { ProxyClient } from './internal/ProxyClient';
-import { TCameraImageConfig, TProxyParam } from './types/common';
+import { TCameraImageConfig, THttpRequestOptions } from './types/common';
 export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
-    client: ProxyClient<Client>;
-    constructor(client: Client, getProxyUrl: () => string);
-    getUrlEncoded(proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
-    postJson(proxy: TProxyParam, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<TResponse>;
-    getCameraImage(params: TCameraImageConfig, proxy?: TProxyParam): Promise<TResponse>;
-    getEventDeclarations(proxy?: TProxyParam): Promise<string>;
-    getSupportedAudioSampleRate(proxy?: TProxyParam): Promise<TAudioSampleRates[]>;
-    performAutofocus(proxy?: TProxyParam): Promise<void>;
-    checkSDCard(proxy?: TProxyParam): Promise<TSDCardInfo>;
-    mountSDCard(proxy?: TProxyParam): Promise<number>;
-    unmountSDCard(proxy?: TProxyParam): Promise<number>;
+    private client;
+    constructor(client: Client);
+    postUrlEncoded(path: string, parameters?: TParameters, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
+    postJson(path: string, jsonData: Record<string, any>, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
+    getCameraImage(parameters: TCameraImageConfig, options?: THttpRequestOptions): Promise<TResponse>;
+    getEventDeclarations(options?: THttpRequestOptions): Promise<string>;
+    getSupportedAudioSampleRate(options?: THttpRequestOptions): Promise<TAudioSampleRates[]>;
+    performAutofocus(options?: THttpRequestOptions): Promise<void>;
+    checkSDCard(options?: THttpRequestOptions): Promise<TSDCardInfo>;
+    mountSDCard(options?: THttpRequestOptions): Promise<number>;
+    unmountSDCard(options?: THttpRequestOptions): Promise<number>;
     private _doSDCardMountAction;
-    fetchSDCardJobProgress(jobId: number, proxy?: TProxyParam): Promise<number>;
-    downloadCameraReport(proxy?: TProxyParam): Promise<TResponse>;
-    getSystemLog(proxy?: TProxyParam): Promise<TResponse>;
-    getMaxFps(channel: number, proxy?: TProxyParam): Promise<number>;
-    getTimezone(proxy?: TProxyParam): Promise<string>;
-    getDateTimeInfo(proxy?: TProxyParam): Promise<{
+    fetchSDCardJobProgress(jobId: number, options?: THttpRequestOptions): Promise<number>;
+    downloadCameraReport(options?: THttpRequestOptions): Promise<TResponse>;
+    getSystemLog(options?: THttpRequestOptions): Promise<TResponse>;
+    getMaxFps(channel: number, options?: THttpRequestOptions): Promise<number>;
+    getTimezone(options?: THttpRequestOptions): Promise<string>;
+    getDateTimeInfo(options?: THttpRequestOptions): Promise<{
         data: {
             dateTime: string;
             dstEnabled: boolean;
@@ -29,13 +28,13 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
             timeZone?: string | undefined;
         };
     }>;
-    getDevicesSettings(proxy?: TProxyParam): Promise<TAudioDevice[]>;
-    fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, proxy?: TProxyParam): Promise<any>;
-    getHeaders(proxy?: TProxyParam): Promise<Record<string, string>>;
-    setHeaders(headers: Record<string, string>, proxy?: TProxyParam): Promise<TResponse>;
-    getParameter(paramNames: string | string[], proxy?: TProxyParam): Promise<Record<string, string>>;
-    setParameter(params: Record<string, string | number | boolean>, proxy?: TProxyParam): Promise<boolean>;
-    getGuardTourList(proxy?: TProxyParam): Promise<{
+    getDevicesSettings(options?: THttpRequestOptions): Promise<TAudioDevice[]>;
+    fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, options?: THttpRequestOptions): Promise<any>;
+    getHeaders(options?: THttpRequestOptions): Promise<Record<string, string>>;
+    setHeaders(headers: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
+    getParameter(paramNames: string | string[], options?: THttpRequestOptions): Promise<Record<string, string>>;
+    setParameter(params: Record<string, string | number | boolean>, options?: THttpRequestOptions): Promise<boolean>;
+    getGuardTourList(options?: THttpRequestOptions): Promise<{
         name: string;
         id: string;
         running: string;
@@ -50,13 +49,13 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
         randomEnabled?: unknown;
         timeBetweenSequences?: unknown;
     }[]>;
-    setGuardTourEnabled(guardTourID: string, enable: boolean, proxy?: TProxyParam): Promise<boolean>;
-    getPTZPresetList(channel: number, proxy?: TProxyParam): Promise<string[]>;
-    listPTZ(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItem[]>;
-    listPtzVideoSourceOverview(proxy?: TProxyParam): Promise<TPtzOverview>;
-    goToPreset(channel: number, presetName: string, proxy?: TProxyParam): Promise<TResponse>;
-    getPtzPosition(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItemData>;
-    getPorts(proxy?: TProxyParam): Promise<{
+    setGuardTourEnabled(guardTourID: string, enable: boolean, options?: THttpRequestOptions): Promise<boolean>;
+    getPTZPresetList(channel: number, options?: THttpRequestOptions): Promise<string[]>;
+    listPTZ(camera: number, options?: THttpRequestOptions): Promise<TCameraPTZItem[]>;
+    listPtzVideoSourceOverview(options?: THttpRequestOptions): Promise<TPtzOverview>;
+    goToPreset(channel: number, presetName: string, options?: THttpRequestOptions): Promise<TResponse>;
+    getPtzPosition(camera: number, options?: THttpRequestOptions): Promise<TCameraPTZItemData>;
+    getPorts(options?: THttpRequestOptions): Promise<{
         name: string;
         port: string;
         state: "open" | "closed";
@@ -66,11 +65,15 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
         normalState: "open" | "closed";
         readonly?: boolean | undefined;
     }[]>;
-    setPorts(ports: TPortSetSchema[], proxy?: TProxyParam): Promise<void>;
-    setPortStateSequence(port: number, sequence: TPortSequenceStateSchema[], proxy?: TProxyParam): Promise<void>;
-    getApplicationList(proxy?: TProxyParam): Promise<any>;
-    startApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
-    restartApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
-    stopApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
-    installApplication(data: Blob, fileName: string): Promise<void>;
+    setPorts(ports: TPortSetSchema[], options?: THttpRequestOptions): Promise<void>;
+    setPortStateSequence(port: number, sequence: TPortSequenceStateSchema[], options?: THttpRequestOptions): Promise<void>;
+    getApplicationList(options?: THttpRequestOptions): Promise<any>;
+    startApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
+    restartApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
+    stopApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
+    installApplication(data: Blob, fileName: string, options?: THttpRequestOptions): Promise<void>;
+    private static parseParameters;
+    private static parseCameraPtzResponse;
+    private static parsePtz;
+    private getAgent;
 }