camstreamerlib 4.0.0-beta.3 → 4.0.0-beta.31

package/esm/CamOverlayPainter/ResourceManager.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs/promises';
-export default class ResourceManager {
+export class ResourceManager {
     co;
     imgFileNames = {};
     fontFileNames = {};
@@ -15,30 +15,26 @@ export default class ResourceManager {
         this.fontFileNames[moniker] = process.env.INSTALL_PATH + '/fonts/' + fileName;
     }
     async image(moniker) {
-        if (moniker in this.images) {
+        if (this.images[moniker] !== undefined) {
             return this.images[moniker];
         }
-        else if (moniker in this.imgFileNames) {
+        if (this.imgFileNames[moniker] !== undefined) {
             const imgData = await fs.readFile(this.imgFileNames[moniker]);
             this.images[moniker] = await this.co.uploadImageData(imgData);
             return this.images[moniker];
         }
-        else {
-            throw new Error('Error! Unknown image requested!');
-        }
+        throw new Error('Error! Unknown image requested!');
     }
     async font(moniker) {
-        if (moniker in this.fonts) {
+        if (this.fonts[moniker] !== undefined) {
             return this.fonts[moniker];
         }
-        else if (moniker in this.fontFileNames) {
+        if (this.fontFileNames[moniker] !== undefined) {
             const fontData = await fs.readFile(this.fontFileNames[moniker]);
             this.fonts[moniker] = await this.co.uploadFontData(fontData);
             return this.fonts[moniker];
         }
-        else {
-            throw new Error('Error! Unknown font requested!');
-        }
+        throw new Error('Error! Unknown font requested!');
     }
     clear() {
         this.images = {};

package/esm/CamScripterAPI.d.ts

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

package/esm/CamScripterAPI.js

@@ -1,52 +1,60 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { packageInfoListSchema, storageSchema, } from './types/CamScripterAPI';
+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 class CamOverlayAPI {
+const BASE_PATH = '/local/camscripter';
+export class CamScripterAPI {
     client;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
     }
-    async checkCameraTime() {
-        return (await this.get('/local/camscripter/camera_time.cgi')).state;
+    static getProxyUrlPath = () => `${BASE_PATH}/proxy.cgi`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
     }
-    async getStorageInfo() {
-        const data = await this.get(`/local/camscripter/package/get_storage.cgi`);
-        return storageSchema.parse(data);
+    async checkCameraTime(options) {
+        const data = await this.get(`${BASE_PATH}/camera_time.cgi`, undefined, options);
+        return cameraTimeResponseSchema.parse(data).state;
+    }
+    async getNetworkCameraList(options) {
+        const data = await this.get(`${BASE_PATH}/network_camera_list.cgi`, undefined, options);
+        return networkCameraListSchema.parse(data.camera_list);
     }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camscripter/network_camera_list.cgi');
-        return networkCameraListSchema.parse(response.camera_list);
+    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('/local/camscripter/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) {
-        await this.post(`/local/camscripter/package/install.cgi?storage=${storage}`, formData);
+    async installPackages(formData, storage, options) {
+        const data = await this.post(`${BASE_PATH}/package/install.cgi?storage=${storage}`, formData, undefined, options);
+        return camscripterApiResponseSchema.parse(data);
     }
-    async uninstallPackage(packageId) {
-        await this.get(`/local/camscripter/package/remove.cgi?package_name=${packageId}`);
+    async uninstallPackage(packageId, options) {
+        const data = await this.get(`${BASE_PATH}/package/remove.cgi?package_name=${packageId}`, undefined, options);
+        return camscripterApiResponseSchema.parse(data);
     }
-    async importSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData);
+    async importSettings(packageId, formData, options) {
+        const data = await this.post(`${BASE_PATH}/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData, undefined, options);
+        return camscripterApiResponseSchema.parse(data);
     }
-    async exportSettings(packageId, formData) {
-        await this.post(`/local/camscripter/package/data.cgi?action=EXPORT&package_name=${packageId}`, formData);
+    async exportSettings(packageId, formData, options) {
+        const data = await this.post(`${BASE_PATH}/package/data.cgi?action=EXPORT&package_name=${packageId}`, formData, undefined, options);
+        return camscripterApiResponseSchema.parse(data);
     }
-    async getNodejsStatus() {
-        return (await this.get('/local/camscripter/diagnostics.cgi')).node_state;
+    async getNodejsStatus(options) {
+        const data = await this.get(`${BASE_PATH}/diagnostics.cgi`, undefined, options);
+        return nodeStateSchema.parse(data);
     }
-    async installNodejs(storage) {
-        await this.get(`/local/camscripter/node_update.cgi?storage=${storage}`);
+    async installNodejs(storage, options) {
+        const data = await this.get(`${BASE_PATH}/node_update.cgi?storage=${storage}`, undefined, options);
+        return camscripterApiResponseSchema.parse(data);
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async get(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
@@ -54,8 +62,9 @@ export class CamOverlayAPI {
             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.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }

package/esm/CamScripterAPICameraEventsGenerator.d.ts

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

package/esm/CamScripterAPICameraEventsGenerator.js

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

package/esm/CamStreamerAPI.d.ts

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

package/esm/CamStreamerAPI.js

@@ -1,56 +1,56 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { streamAttributesSchema, streamListSchema, } from './types/CamStreamerAPI';
+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(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
+    }
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.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.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }

package/esm/CamSwitcherAPI.d.ts

@@ -1,46 +1,52 @@
-import { IClient } from './internal/common';
+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';
-export declare class CamSwitcherAPI<Client extends IClient = IClient> {
+import { TAudioChannel, THttpRequestOptions, TNetworkCamera, TProxyParams, TStorageType } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     client: Client;
+    private CustomFormData;
     private vapixAgent;
-    constructor(client: Client);
+    constructor(client: Client, CustomFormData?: {
+        new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
+        prototype: FormData;
+    });
     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>;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
+    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;