camstreamerlib 1.6.1 → 1.6.2

package/CamOverlayAPI.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+export declare type CamOverlayOptions = {
+    protocol: string;
+    ip: string;
+    port: number;
+    auth: string;
+    serviceName: string;
+    serviceID: number;
+    camera: number;
+};
+export declare type Field = {
+    field_name: string;
+    text: string;
+    color?: string;
+};
+declare type Service = {
+    id: number;
+    enabled: number;
+    schedule: string;
+    name: string;
+    identifier: string;
+    camera: number;
+};
+declare type ServiceJson = {
+    services: Service[];
+};
+export declare class CamOverlayAPI extends EventEmitter {
+    private protocol;
+    private ip;
+    private port;
+    private auth;
+    private serviceName;
+    private serviceID;
+    private camera;
+    private callId;
+    private sendMessages;
+    private ws;
+    constructor(options?: CamOverlayOptions);
+    connect(): Promise<void>;
+    createService(): Promise<number>;
+    updateServices(servicesJson: ServiceJson): Promise<void>;
+    openWebsocket(digestHeader?: string): Promise<void>;
+    cairo(command: string, ...params: any[]): Promise<unknown>;
+    writeText(...params: any[]): Promise<unknown>;
+    uploadImageData(imgBuffer: Buffer): Promise<unknown>;
+    uploadFontData(fontBuffer: Buffer): Promise<unknown>;
+    showCairoImage(cairoImage: any, posX: number, posY: number): Promise<unknown>;
+    removeImage(): Promise<unknown>;
+    showCairoImageAbsolute(cairoImage: any, posX: number, posY: number, width: number, height: number): Promise<unknown>;
+    sendMessage(msgJson: any): Promise<unknown>;
+    reportMsg(msg: string): void;
+    reportErr(err: Error): void;
+    reportClose(): void;
+    updateCGText(fields: Field[]): Promise<void>;
+    private formCoordinates;
+    updateCGImage(path: string, coordinates?: string, x?: number, y?: number): Promise<void>;
+    updateCGImagePos(coordinates?: string, x?: number, y?: number): Promise<void>;
+    promiseCGUpdate(action: string, params: string): Promise<void>;
+    updateInfoticker(text: string): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
+    isEnabled(): Promise<boolean>;
+}
+export {};

package/CamOverlayAPI.js

@@ -0,0 +1,301 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamOverlayAPI = void 0;
+const WebSocket = require("ws");
+const EventEmitter = require("events");
+const Digest_1 = require("./Digest");
+const HTTPRequest_1 = require("./HTTPRequest");
+class CamOverlayAPI extends EventEmitter {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        super();
+        this.ws = null;
+        this.protocol = (_a = options === null || options === void 0 ? void 0 : options.protocol) !== null && _a !== void 0 ? _a : 'ws';
+        this.ip = (_b = options === null || options === void 0 ? void 0 : options.ip) !== null && _b !== void 0 ? _b : '127.0.0.1';
+        this.port = ((_c = options === null || options === void 0 ? void 0 : options.port) !== null && _c !== void 0 ? _c : this.protocol == 'ws') ? 80 : 443;
+        this.auth = (_d = options === null || options === void 0 ? void 0 : options.auth) !== null && _d !== void 0 ? _d : '';
+        this.serviceName = (_e = options === null || options === void 0 ? void 0 : options.serviceName) !== null && _e !== void 0 ? _e : '';
+        this.serviceID = (_f = options === null || options === void 0 ? void 0 : options.serviceID) !== null && _f !== void 0 ? _f : -1;
+        this.camera = (_g = options === null || options === void 0 ? void 0 : options.camera) !== null && _g !== void 0 ? _g : 0;
+        this.callId = 0;
+        this.sendMessages = {};
+        EventEmitter.call(this);
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.serviceID != -1) {
+                yield this.openWebsocket();
+            }
+            else {
+                try {
+                    let id = yield this.createService();
+                    this.serviceID = id;
+                    yield this.openWebsocket();
+                }
+                catch (err) {
+                    this.reportErr(err);
+                }
+            }
+        });
+    }
+    createService() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                host: this.ip,
+                port: this.port,
+                path: '/local/camoverlay/api/services.cgi?action=get',
+                auth: this.auth,
+            };
+            const response = (yield (0, HTTPRequest_1.httpRequest)(options));
+            let servicesJson;
+            try {
+                servicesJson = JSON.parse(response);
+                (_a = servicesJson.services) !== null && _a !== void 0 ? _a : (servicesJson.services = []);
+            }
+            catch (_b) {
+                servicesJson = { services: [] };
+            }
+            let service = null;
+            let maxID = -1;
+            let servicesArr = servicesJson.services;
+            for (let s of servicesArr) {
+                if (s.id > maxID) {
+                    maxID = s.id;
+                }
+                if (s.identifier == this.serviceName && s.name == 'scripter') {
+                    service = s;
+                    break;
+                }
+            }
+            if (service != null) {
+                if (service.enabled == 1) {
+                    if (service.camera == undefined || service.camera != this.camera) {
+                        service.camera = this.camera;
+                        yield this.updateServices(servicesJson);
+                        return service.id;
+                    }
+                    else {
+                        return service.id;
+                    }
+                }
+                else {
+                    throw new Error('CamOverlay service is not enabled');
+                }
+            }
+            else {
+                let newServiceID = maxID + 1;
+                service = {
+                    id: newServiceID,
+                    enabled: 1,
+                    schedule: '',
+                    name: 'scripter',
+                    identifier: this.serviceName,
+                    camera: this.camera,
+                };
+                servicesJson.services.push(service);
+                yield this.updateServices(servicesJson);
+                return newServiceID;
+            }
+        });
+    }
+    updateServices(servicesJson) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                method: 'POST',
+                host: this.ip,
+                port: this.port,
+                path: '/local/camoverlay/api/services.cgi?action=set',
+                auth: this.auth,
+            };
+            yield (0, HTTPRequest_1.httpRequest)(options, JSON.stringify(servicesJson));
+        });
+    }
+    openWebsocket(digestHeader) {
+        let promise = new Promise((resolve, reject) => {
+            let userPass = this.auth.split(':');
+            let addr = `${this.protocol}://${this.ip}:${this.port}/local/camoverlay/ws`;
+            let options = {
+                auth: this.auth,
+                headers: {},
+            };
+            if (digestHeader != undefined) {
+                options.headers['Authorization'] = Digest_1.Digest.getAuthHeader(userPass[0], userPass[1], 'GET', '/local/camoverlay/ws', digestHeader);
+            }
+            this.ws = new WebSocket(addr, 'cairo-api', options);
+            this.ws.on('open', () => {
+                this.reportMsg('Websocket opened');
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                let dataJSON = JSON.parse(data);
+                if (dataJSON.hasOwnProperty('call_id') && dataJSON['call_id'] in this.sendMessages) {
+                    this.sendMessages[dataJSON['call_id']].resolve(dataJSON);
+                    delete this.sendMessages[dataJSON['call_id']];
+                }
+                if (dataJSON.hasOwnProperty('error')) {
+                    let error = new Error(JSON.stringify(data));
+                    this.reportErr(error);
+                }
+                else {
+                    this.reportMsg(data);
+                }
+            });
+            this.ws.on('unexpected-response', (req, res) => __awaiter(this, void 0, void 0, function* () {
+                if (res.statusCode == 401 && res.headers['www-authenticate'] != undefined)
+                    this.openWebsocket(res.headers['www-authenticate']).then(resolve, reject);
+                else {
+                    reject('Error: status code: ' + res.statusCode + ', ' + res.data);
+                }
+            }));
+            this.ws.on('error', (error) => {
+                this.reportErr(error);
+                reject(error);
+            });
+            this.ws.on('close', () => {
+                this.reportClose();
+            });
+        });
+        return promise;
+    }
+    cairo(command, ...params) {
+        return this.sendMessage({ command: command, params: params });
+    }
+    writeText(...params) {
+        return this.sendMessage({ command: 'write_text', params: params });
+    }
+    uploadImageData(imgBuffer) {
+        return this.sendMessage({ command: 'upload_image_data', params: [imgBuffer.toString('base64')] });
+    }
+    uploadFontData(fontBuffer) {
+        return this.sendMessage({ command: 'upload_font_data', params: [fontBuffer.toString('base64')] });
+    }
+    showCairoImage(cairoImage, posX, posY) {
+        return this.sendMessage({ command: 'show_cairo_image', params: [this.serviceID, cairoImage, posX, posY] });
+    }
+    removeImage() {
+        return this.sendMessage({ command: 'remove_image', params: [this.serviceID] });
+    }
+    showCairoImageAbsolute(cairoImage, posX, posY, width, height) {
+        return this.sendMessage({
+            command: 'show_cairo_image',
+            params: [this.serviceID, cairoImage, -1.0 + (2.0 / width) * posX, -1.0 + (2.0 / height) * posY],
+        });
+    }
+    sendMessage(msgJson) {
+        let promise = new Promise((resolve, reject) => {
+            try {
+                this.sendMessages[this.callId] = { resolve, reject };
+                msgJson['call_id'] = this.callId++;
+                this.ws.send(JSON.stringify(msgJson));
+            }
+            catch (err) {
+                this.reportErr(new Error(`Send message error: ${err}`));
+            }
+        });
+        return promise;
+    }
+    reportMsg(msg) {
+        this.emit('msg', msg);
+    }
+    reportErr(err) {
+        var _a;
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.terminate();
+        this.emit('error', err);
+    }
+    reportClose() {
+        this.emit('close');
+    }
+    updateCGText(fields) {
+        let field_specs = '';
+        for (let field of fields) {
+            const name = field.field_name;
+            field_specs += `&${name}=${field.text}`;
+            if (field.color != undefined) {
+                field_specs += `&${name}_color=${field.color}`;
+            }
+        }
+        return this.promiseCGUpdate('update_text', field_specs);
+    }
+    formCoordinates(coordinates, x, y) {
+        return coordinates != '' ? `&coord_system=${coordinates}&pos_x=${x}&pos_y=${y}` : '';
+    }
+    updateCGImage(path, coordinates = '', x = 0, y = 0) {
+        const coord = this.formCoordinates(coordinates, x, y);
+        const update = `&image=${path}`;
+        return this.promiseCGUpdate('update_image', update + coord);
+    }
+    updateCGImagePos(coordinates = '', x = 0, y = 0) {
+        const coord = this.formCoordinates(coordinates, x, y);
+        return this.promiseCGUpdate('update_image', coord);
+    }
+    promiseCGUpdate(action, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = encodeURI(`/local/camoverlay/api/customGraphics.cgi?action=${action}&service_id=${this.serviceID}${params}`);
+            const options = {
+                method: 'POST',
+                host: this.ip,
+                port: this.port,
+                path: path,
+                auth: this.auth,
+            };
+            yield (0, HTTPRequest_1.httpRequest)(options, '');
+        });
+    }
+    updateInfoticker(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = `/local/camoverlay/api/infoticker.cgi?service_id=${this.serviceID}&text=${text}`;
+            const options = {
+                method: 'GET',
+                host: this.ip,
+                port: this.port,
+                path: path,
+                auth: this.auth,
+            };
+            yield (0, HTTPRequest_1.httpRequest)(options, '');
+        });
+    }
+    setEnabled(enabled) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = enabled ? 1 : 0;
+            const path = encodeURI(`/local/camoverlay/api/enabled.cgi?id${this.serviceID}=${value}`);
+            const options = {
+                method: 'POST',
+                host: this.ip,
+                port: this.port,
+                path: path,
+                auth: this.auth,
+            };
+            yield (0, HTTPRequest_1.httpRequest)(options, '');
+        });
+    }
+    isEnabled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                method: 'GET',
+                host: this.ip,
+                port: this.port,
+                path: '/local/camoverlay/api/services.cgi?action=get',
+                auth: this.auth,
+            };
+            const response = (yield (0, HTTPRequest_1.httpRequest)(options, ''));
+            const data = JSON.parse(response);
+            for (let service of data.services) {
+                if (service.id == this.serviceID) {
+                    return service.enabled == 1;
+                }
+            }
+            throw new Error('Service not found.');
+        });
+    }
+}
+exports.CamOverlayAPI = CamOverlayAPI;

package/CamStreamerAPI.d.ts

@@ -0,0 +1,19 @@
+export declare type CamStreamerAPIOptions = {
+    protocol: string;
+    ip: string;
+    port: number;
+    auth: string;
+};
+export declare class CamStreamerAPI {
+    private protocol;
+    private ip;
+    private port;
+    private auth;
+    constructor(options?: CamStreamerAPIOptions);
+    getStreamList(): Promise<any>;
+    getStreamParameter(streamID: string, paramName: string): Promise<any>;
+    setStreamParameter(streamID: string, paramName: string, value: string): Promise<any>;
+    isStreaming(streamID: string): Promise<any>;
+    get(path: string): Promise<any>;
+    private getBaseConnectionParams;
+}

package/CamStreamerAPI.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamStreamerAPI = void 0;
+const HTTPRequest_1 = require("./HTTPRequest");
+class CamStreamerAPI {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        this.protocol = (_a = options === null || options === void 0 ? void 0 : options.protocol) !== null && _a !== void 0 ? _a : 'http';
+        this.ip = (_b = options === null || options === void 0 ? void 0 : options.ip) !== null && _b !== void 0 ? _b : '127.0.0.1';
+        this.port = ((_c = options === null || options === void 0 ? void 0 : options.port) !== null && _c !== void 0 ? _c : this.protocol == 'http') ? 80 : 443;
+        this.auth = (_d = options === null || options === void 0 ? void 0 : options.auth) !== null && _d !== void 0 ? _d : '';
+    }
+    getStreamList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const streamListRes = yield this.get('/local/camstreamer/stream/list.cgi');
+            return streamListRes.data;
+        });
+    }
+    getStreamParameter(streamID, paramName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stream = yield this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
+            return stream.data[paramName];
+        });
+    }
+    setStreamParameter(streamID, paramName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.get(`/local/camstreamer/stream/set.cgi?stream_id=${streamID}&${paramName}=${value}`);
+        });
+    }
+    isStreaming(streamID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.get(`/local/camstreamer/get_streamstat.cgi?stream_id=${streamID}`);
+            return response.data.is_streaming;
+        });
+    }
+    get(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = this.getBaseConnectionParams();
+            options.path = encodeURI(path);
+            const data = (yield (0, HTTPRequest_1.httpRequest)(options));
+            return JSON.parse(data);
+        });
+    }
+    getBaseConnectionParams() {
+        return {
+            protocol: this.protocol + ':',
+            host: this.ip,
+            port: this.port,
+            auth: this.auth,
+        };
+    }
+}
+exports.CamStreamerAPI = CamStreamerAPI;

package/CamSwitcherAPI.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+export declare type CamSwitcherAPIOptions = {
+    ip?: string;
+    port?: number;
+    auth?: string;
+};
+export declare class CamSwitcherAPI extends EventEmitter {
+    private ip;
+    private port;
+    private auth;
+    private ws;
+    private pingTimer;
+    constructor(options: CamSwitcherAPIOptions);
+    connect(): Promise<void>;
+    getPlaylistList(): Promise<object>;
+    getClipList(): Promise<object>;
+    playlistSwitch(playlistName: string): Promise<object>;
+    playlistQueueList(): Promise<object>;
+    playlistQueueClear(): Promise<object>;
+    playlistQueuePush(playlistName: string): Promise<object>;
+    playlistQueuePlayNext(): Promise<object>;
+    getOutputInfo(): Promise<object>;
+    get(path: string): Promise<object>;
+    private getBaseConnectionParams;
+}

package/CamSwitcherAPI.js

@@ -0,0 +1,119 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamSwitcherAPI = void 0;
+const WebSocket = require("ws");
+const EventEmitter = require("events");
+const HTTPRequest_1 = require("./HTTPRequest");
+class CamSwitcherAPI extends EventEmitter {
+    constructor(options) {
+        var _a, _b, _c;
+        super();
+        this.ip = (_a = options === null || options === void 0 ? void 0 : options.ip) !== null && _a !== void 0 ? _a : '127.0.0.1';
+        this.port = (_b = options === null || options === void 0 ? void 0 : options.port) !== null && _b !== void 0 ? _b : 80;
+        this.auth = (_c = options === null || options === void 0 ? void 0 : options.auth) !== null && _c !== void 0 ? _c : '';
+        EventEmitter.call(this);
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const token = yield this.get('/local/camswitcher/ws_authorization.cgi');
+                this.ws = new WebSocket(`ws://${this.ip}:${this.port}/local/camswitcher/events`, 'events');
+                this.pingTimer = null;
+                this.ws.on('open', () => {
+                    this.ws.send(JSON.stringify({ authorization: token }));
+                    this.ws.isAlive = true;
+                    this.pingTimer = setInterval(() => {
+                        if (this.ws.isAlive === false) {
+                            return this.ws.terminate();
+                        }
+                        this.ws.isAlive = false;
+                        this.ws.ping();
+                    }, 30000);
+                });
+                this.ws.on('pong', () => {
+                    this.ws.isAlive = true;
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const parsedData = JSON.parse(data);
+                        this.emit('event', parsedData);
+                    }
+                    catch (err) {
+                        console.log(err);
+                    }
+                });
+                this.ws.on('close', () => {
+                    clearInterval(this.pingTimer);
+                    this.emit('event_connection_close');
+                });
+                this.ws.on('error', (err) => {
+                    this.emit('event_connection_error', err);
+                });
+            }
+            catch (err) {
+                this.emit('event_connection_error', err);
+            }
+        });
+    }
+    getPlaylistList() {
+        return this.get('/local/camswitcher/playlists.cgi?action=get');
+    }
+    getClipList() {
+        return this.get('/local/camswitcher/clips.cgi?action=get');
+    }
+    playlistSwitch(playlistName) {
+        return this.get(`/local/camswitcher/playlist_switch.cgi?playlist_name=${playlistName}`);
+    }
+    playlistQueueList() {
+        return this.get('/local/camswitcher/playlist_queue_list.cgi');
+    }
+    playlistQueueClear() {
+        return this.get('/local/camswitcher/playlist_queue_clear.cgi');
+    }
+    playlistQueuePush(playlistName) {
+        return this.get(`/local/camswitcher/playlist_queue_push.cgi?playlist_name=${playlistName}`);
+    }
+    playlistQueuePlayNext() {
+        return this.get('/local/camswitcher/playlist_queue_play_next.cgi');
+    }
+    getOutputInfo() {
+        return this.get('/local/camswitcher/output_info.cgi');
+    }
+    get(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = this.getBaseConnectionParams();
+            options.path = encodeURI(path);
+            const data = (yield (0, HTTPRequest_1.httpRequest)(options));
+            try {
+                const response = JSON.parse(data);
+                if (response.status == 200) {
+                    return response.data;
+                }
+                else {
+                    throw new Error(`Request (${path}) error, response: ${JSON.stringify(response)}`);
+                }
+            }
+            catch (err) {
+                throw new Error(`Request (${path}) error: ${err}, msg: ${data}`);
+            }
+        });
+    }
+    getBaseConnectionParams() {
+        return {
+            protocol: 'http:',
+            host: this.ip,
+            port: this.port,
+            auth: this.auth,
+        };
+    }
+}
+exports.CamSwitcherAPI = CamSwitcherAPI;

package/CameraVapix.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+export declare type CameraVapixOptions = {
+    protocol?: string;
+    ip?: string;
+    port?: number;
+    auth?: string;
+};
+export declare type ApplicationList = {
+    reply: {
+        $: {
+            result: string;
+        };
+        application: {
+            $: Application;
+        }[];
+    };
+};
+export declare type Application = {
+    Name: string;
+    NiceName: string;
+    Vendor: string;
+    Version: string;
+    ApplicationID?: string;
+    License: string;
+    Status: string;
+    ConfigurationPage?: string;
+    VendorHomePage?: string;
+    LicenseName?: string;
+};
+export declare type GuardTour = {
+    id: string;
+    camNbr: any;
+    name: string;
+    randomEnabled: any;
+    running: string;
+    timeBetweenSequences: any;
+    tour: {
+        moveSpeed: any;
+        position: any;
+        presetNbr: any;
+        waitTime: any;
+        waitTimeViewType: any;
+    }[];
+};
+export declare class CameraVapix extends EventEmitter {
+    private protocol;
+    private ip;
+    private port;
+    private auth;
+    private rtsp;
+    private ws;
+    constructor(options?: CameraVapixOptions);
+    getParameterGroup(groupNames: string): Promise<{}>;
+    setParameter(params: object): Promise<string>;
+    getPTZPresetList(channel: string): Promise<string[]>;
+    goToPreset(channel: number, presetName: string): Promise<string>;
+    getGuardTourList(): Promise<GuardTour[]>;
+    setGuardTourEnabled(gourTourID: string, enable: boolean): Promise<string>;
+    getInputState(port: number): Promise<boolean>;
+    setOutputState(port: number, active: boolean): Promise<string>;
+    getApplicationList(): Promise<Application[]>;
+    getEventDeclarations(): Promise<string>;
+    private isReservedEventName;
+    eventsConnect(channel?: string): void;
+    eventsDisconnect(): void;
+    private rtspConnect;
+    private websocketConnect;
+    vapixGet(path: string, noWaitForData?: boolean): Promise<string | http.IncomingMessage>;
+    getCameraImage(camera: string, compression: string, resolution: string, outputStream: NodeJS.WritableStream): Promise<NodeJS.WritableStream>;
+    vapixPost(path: string, data: string, contentType?: string): Promise<string>;
+    private getBaseVapixConnectionParams;
+}