camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.4

package/esm/CamOverlayPainter/Frame.d.ts

@@ -0,0 +1,96 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CamOverlayDrawingAPI, TAlign, TCairoCreateResponse, TUploadImageResponse } from '../CamOverlayDrawingAPI';
+import ResourceManager from './ResourceManager';
+export type TRgb = [number, number, number];
+export type TRgba = [number, number, number, number];
+export type TTmf = 'TFM_OVERFLOW' | 'TFM_SCALE' | 'TFM_TRUNCATE';
+export type TObjectFitType = 'fill' | 'fit' | 'none';
+export type TFrameOptions = {
+    enabled?: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text?: string;
+    fontColor?: TRgb;
+    font?: string;
+    bgColor?: TRgba;
+    bgImage?: string;
+    bgType?: TObjectFitType;
+    borderRadius?: number;
+    borderWidth?: number;
+    borderColor?: TRgba;
+    customDraw?: TDrawingCallback;
+    layer?: number;
+};
+export type TFrameInfo = {
+    width: number;
+    height: number;
+};
+export type TDrawingCallback = (cod: CamOverlayDrawingAPI, cairo: string, info: TFrameInfo) => Promise<void>;
+export interface Frame {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'layoutChanged', listener: () => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'layoutChanged'): boolean;
+}
+export declare class Frame extends EventEmitter {
+    protected enabled: boolean;
+    protected posX: number;
+    protected posY: number;
+    protected width: number;
+    protected height: number;
+    private text;
+    private fontColor;
+    private fontName?;
+    private font?;
+    private align;
+    private textType;
+    private bgColor?;
+    private bgImageName?;
+    private bgImage?;
+    private bgType?;
+    private borderRadius;
+    private borderWidth;
+    private borderColor;
+    private customDraw?;
+    private layer;
+    protected children: Frame[];
+    constructor(opt: TFrameOptions);
+    enable(): void;
+    disable(): void;
+    setFramePosition(x: number, y: number): void;
+    setFrameSize(width: number, height: number): void;
+    setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
+    setFontColor(fontColor: TRgb): void;
+    setFont(fontName: string): void;
+    setFontData(fontData: TCairoCreateResponse): void;
+    setBgColor(color: TRgba): void;
+    setBgImage(imageName: string, type?: TObjectFitType): void;
+    setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
+    setBgType(type: TObjectFitType): void;
+    setBorderRadius(radius: number): void;
+    setBorderWidth(width: number): void;
+    setBorderColor(color: TRgba): void;
+    setCustomDraw(customDraw: TDrawingCallback): void;
+    resetFont(): void;
+    resetBgColor(): void;
+    resetBgImage(): void;
+    resetCustomDraw(): void;
+    clear(): void;
+    insert(...frames: Frame[]): void;
+    getLayers(): Set<number>;
+    protected layoutChanged(): void;
+    displayImage(cod: CamOverlayDrawingAPI, resourceManager: ResourceManager, cairo: string, ppX: number, ppY: number, scale: number, layer: number): Promise<void>;
+    private prepareResources;
+    protected displayOwnImage(cod: CamOverlayDrawingAPI, cairo: string, ppX: number, ppY: number, scale: number): Promise<void>;
+    private clipDrawing;
+    private drawFrame;
+    private drawImage;
+    private drawText;
+    private drawBorder;
+    private drawRectPath;
+}

package/esm/CamOverlayPainter/Painter.d.ts

@@ -0,0 +1,48 @@
+import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
+import ResourceManager from './ResourceManager';
+import { Frame, TFrameOptions } from './Frame';
+export declare const COORD: {
+    readonly top_left: readonly [-1, -1];
+    readonly center_left: readonly [-1, 0];
+    readonly bottom_left: readonly [-1, 1];
+    readonly top_center: readonly [0, -1];
+    readonly center: readonly [0, 0];
+    readonly bottom_center: readonly [0, 1];
+    readonly top_right: readonly [1, -1];
+    readonly center_right: readonly [1, 0];
+    readonly bottom_right: readonly [1, 1];
+};
+type TCoAlignment = keyof typeof COORD;
+export type TPainterOptions = TFrameOptions & {
+    screenWidth: number;
+    screenHeight: number;
+    coAlignment: TCoAlignment;
+};
+export declare class Painter extends Frame {
+    private screenWidth;
+    private screenHeight;
+    private coAlignment;
+    private cod;
+    private rm;
+    private refreshLayers;
+    private layers;
+    constructor(opt: TPainterOptions, coopt: CamOverlayDrawingOptions);
+    get camOverlayDrawingAPI(): CamOverlayDrawingAPI;
+    get resourceManager(): ResourceManager;
+    connect(): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    registerImage(moniker: string, fileName: string): void;
+    registerFont(moniker: string, fileName: string): void;
+    setScreenSize(sw: number, sh: number): void;
+    setCoAlignment(coAlignment: TCoAlignment): void;
+    protected layoutChanged(): void;
+    display(scale?: number): Promise<void>;
+    hide(): Promise<void>;
+    invalidateLayer(layer: number): Promise<void>;
+    private prepareLayers;
+    private prepareSurface;
+    private cleanupSurface;
+    private positionConvertor;
+}
+export { Frame, TFrameOptions as FrameOptions, ResourceManager, CamOverlayDrawingOptions };

package/{CamOverlayPainter → esm/CamOverlayPainter}/Painter.js

@@ -82,6 +82,9 @@ export class Painter extends Frame {
             let lastCachedLayer;
             for (let i = 0; i < this.layers.length; i++) {
                 const layer = this.layers[i];
+                if (layer === undefined) {
+                    continue;
+                }
                 if (layer.cairoCache !== undefined &&
                     layer.surfaceCache !== undefined &&
                     surface === undefined &&
@@ -115,7 +118,7 @@ export class Painter extends Frame {
         }
         for (let i = layerIdx; i < this.layers.length; i++) {
             const currentLayer = this.layers[i];
-            if (currentLayer.surfaceCache !== undefined && currentLayer.cairoCache !== undefined) {
+            if (currentLayer?.surfaceCache !== undefined && currentLayer.cairoCache !== undefined) {
                 await this.cleanupSurface(currentLayer.surfaceCache, currentLayer.cairoCache);
                 currentLayer.surfaceCache = undefined;
                 currentLayer.cairoCache = undefined;

package/esm/CamOverlayPainter/ResourceManager.d.ts

@@ -0,0 +1,14 @@
+import { CamOverlayDrawingAPI, TUploadImageResponse, TCairoCreateResponse } from '../CamOverlayDrawingAPI';
+export default class ResourceManager {
+    private co;
+    private imgFileNames;
+    private fontFileNames;
+    private images;
+    private fonts;
+    constructor(co: CamOverlayDrawingAPI);
+    registerImage(moniker: string, fileName: string): void;
+    registerFont(moniker: string, fileName: string): void;
+    image(moniker: string): Promise<TUploadImageResponse>;
+    font(moniker: string): Promise<TCairoCreateResponse>;
+    clear(): void;
+}

package/{CamOverlayPainter → esm/CamOverlayPainter}/ResourceManager.js

@@ -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

@@ -0,0 +1,19 @@
+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>;
+    private get;
+    private post;
+}

package/esm/CamScripterAPICameraEventsGenerator.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from './internal/common';
+export type CamScripterOptions = WsOptions;
+export type TDeclaration = {
+    type?: '' | 'SOURCE' | 'DATA';
+    namespace: string;
+    key: string;
+    value: string | boolean | number;
+    value_type: 'STRING' | 'INT' | 'BOOL' | 'DOUBLE';
+    key_nice_name?: string;
+    value_nice_name?: string;
+};
+export type TEventDeclaration = {
+    declaration_id: string;
+    stateless: boolean;
+    declaration: TDeclaration[];
+};
+export type TEventUndeclaration = {
+    declaration_id: string;
+};
+export type TEventData = {
+    namespace: string;
+    key: string;
+    value: string | boolean | number;
+    value_type: 'STRING' | 'INT' | 'BOOL' | 'DOUBLE';
+};
+export type TEvent = {
+    declaration_id: string;
+    event_data: TEventData[];
+};
+export type TResponse = {
+    call_id: number;
+    message: string;
+};
+export type TErrorResponse = {
+    error: string;
+    call_id?: number;
+};
+export interface CamScripterAPICameraEventsGenerator {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+}
+export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private callId;
+    private sendMessages;
+    private timeoutCheckTimer;
+    private wsConnected;
+    private ws;
+    constructor(options?: CamScripterOptions);
+    connect(): void;
+    disconnect(): void;
+    declareEvent(eventDeclaration: TEventDeclaration): Promise<TResponse>;
+    undeclareEvent(eventUndeclaration: TEventUndeclaration): Promise<TResponse>;
+    sendEvent(event: TEvent): Promise<TResponse>;
+    private createWsClient;
+    private incomingWsMessageHandler;
+    private sendMessage;
+    private startMsgsTimeoutCheck;
+    private stopMsgsTimeoutCheck;
+    private reconnectWithError;
+    private reportErr;
+    private reportClose;
+}

package/{CamScripterAPICameraEventsGenerator.js → 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

@@ -0,0 +1,16 @@
+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>;
+    private get;
+}

package/esm/CamSwitcherAPI.d.ts

@@ -0,0 +1,48 @@
+import { IClient } from './internal/common';
+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> {
+    client: Client;
+    private vapixAgent;
+    constructor(client: Client);
+    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>;
+    private get;
+    private set;
+    private setParamFromCameraJSON;
+    private getParamFromCameraAndJSONParse;
+}

package/{CamSwitcherAPI.js → esm/CamSwitcherAPI.js}

@@ -15,9 +15,9 @@ export class CamSwitcherAPI {
         this.client = client;
         this.vapixAgent = new VapixAPI(client, () => '');
     }
-    static getProxyUrl = () => `${baseUrl}/proxy.cgi`;
-    static getWsEventsUrl = () => `/local/camswitcher/events`;
-    static getClipPreview = (id, storage) => `${baseUrl}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
+    static getProxyUrlPath = () => `${baseUrl}/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(),
@@ -292,16 +292,12 @@ const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, c
     if (bitrateMode === null) {
         return '';
     }
-    if (bitrateMode === 'VBR') {
-        return 'videobitratemode=vbr';
-    }
-    if (bitrateMode === 'MBR') {
-        return `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}`;
-    }
-    if (bitrateMode === 'ABR') {
-        return `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`;
-    }
-    throw new Error('Unknown bitrateMode param in getVapixParams method.');
+    const data = {
+        VBR: 'videobitratemode=vbr',
+        MBR: `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}`,
+        ABR: `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`,
+    };
+    return data[bitrateMode];
 };
 const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
     const params = {};
@@ -312,7 +308,7 @@ const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
     const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
     const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
     if (hasLowerFw) {
-        const maximumBitRate = parseInt(params['videomaxbitrate'], 10);
+        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
         return {
             bitrateMode: 'MBR',
             maximumBitRate: maximumBitRate,
@@ -321,19 +317,19 @@ const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
         };
     }
     if (bitrateMode === 'ABR') {
-        const maximumBitRate = parseInt(params['videoabrtargetbitrate'], 10);
-        const retentionTime = parseInt(params['videoabrretentiontime'], 10);
-        const bitrateLimit = parseInt(params['videoabrmaxbitrate'], 10);
+        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
+        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
+        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
         return {
-            bitrateMode: bitrateMode,
-            maximumBitRate: maximumBitRate,
-            retentionTime: retentionTime,
-            bitRateLimit: bitrateLimit,
+            bitrateMode,
+            maximumBitRate,
+            retentionTime,
+            bitRateLimit,
         };
     }
     else if (bitrateMode === 'MBR') {
-        const maximumBitRate = parseInt(params['videomaxbitrate'], 10);
-        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'], 10);
+        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
+        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
         return {
             bitrateMode: bitrateMode,
             maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,

package/esm/CamSwitcherEvents.d.ts

@@ -0,0 +1,18 @@
+import { IWebsocket } from './internal/common';
+import { TCamSwitcherEventOfType, TCamSwitcherEventType } from './types/CamSwitcherEvents';
+type TListenerFunction<T extends TCamSwitcherEventType> = (data: TCamSwitcherEventOfType<T>, isInit: boolean) => void;
+export declare class CamSwitcherEvents<Event extends {
+    data: string;
+}> {
+    isDestroyed: boolean;
+    private ws;
+    private listeners;
+    setWebsocket(ws: IWebsocket<Event>): void;
+    resendInitData(): void;
+    addListener<T extends TCamSwitcherEventType>(type: T, listener: TListenerFunction<T>, id: string): void;
+    removeListener<T extends TCamSwitcherEventType>(type: T, id: string): void;
+    private onMessage;
+    private processMessage;
+    destroy(): void;
+}
+export {};

package/{CamSwitcherEvents.js → esm/CamSwitcherEvents.js}

@@ -1,4 +1,4 @@
-import { cswEventsSchema, } from './types/CamswitcherEvents';
+import { cswEventsSchema, } from './types/CamSwitcherEvents';
 export class CamSwitcherEvents {
     isDestroyed = false;
     ws = null;

package/esm/CreatePackage.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/VapixAPI.d.ts

@@ -0,0 +1,66 @@
+import { IClient, TParameters } from './internal/common';
+import { TApplication, TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice } from './types/VapixAPI';
+import { ProxyClient } from './internal/ProxyClient';
+import { TCameraImageConfig, TProxyParam } from './types/common';
+export declare class VapixAPI<Client extends IClient = IClient> {
+    client: ProxyClient<Client>;
+    constructor(client: Client, getProxyUrl: () => string);
+    getUrlEncoded(proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<import("./internal/common").TResponse>;
+    postJson(proxy: TProxyParam, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<import("./internal/common").TResponse>;
+    getCameraImage(params: TCameraImageConfig, proxy?: TProxyParam): Promise<import("./internal/common").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 _doSDCardMountAction;
+    fetchSDCardJobProgress(jobId: number, proxy?: TProxyParam): Promise<number>;
+    downloadCameraReport(proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
+    getSystemLog(proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
+    getMaxFps(channel: number, proxy?: TProxyParam): Promise<number>;
+    getTimezone(proxy?: TProxyParam): Promise<string>;
+    getDateTimeInfo(proxy?: TProxyParam): Promise<{
+        data: {
+            dateTime: string;
+            dstEnabled: boolean;
+            localDateTime: string;
+            posixTimeZone: string;
+            timeZone: string;
+        };
+    }>;
+    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<import("./internal/common").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<{
+        name: string;
+        id: string;
+        running: string;
+        tour: {
+            moveSpeed?: unknown;
+            position?: unknown;
+            presetNbr?: unknown;
+            waitTime?: unknown;
+            waitTimeViewType?: unknown;
+        }[];
+        camNbr?: unknown;
+        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<import("./internal/common").TResponse>;
+    getPtzPosition(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItemData>;
+    getInputState(port: number, proxy?: TProxyParam): Promise<boolean>;
+    setOutputState(port: number, active: boolean, proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
+    getApplicationList(proxy?: TProxyParam): Promise<TApplication[]>;
+    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>;
+}