camstreamerlib 4.0.0-beta.9 → 4.0.0-beta.91

package/cjs/{CamScripterAPICameraEventsGenerator.js → node/CamScripterAPICameraEventsGenerator.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamScripterAPICameraEventsGenerator = void 0;
-const EventEmitter = require("events");
-const WsClient_1 = require("./node/WsClient");
-class CamScripterAPICameraEventsGenerator extends EventEmitter {
+const events_1 = require("events");
+const WsClient_1 = require("./WsClient");
+class CamScripterAPICameraEventsGenerator extends events_1.EventEmitter {
     tls;
     tlsInsecure;
     ip;
@@ -27,14 +27,14 @@ class CamScripterAPICameraEventsGenerator extends EventEmitter {
         this.sendMessages = {};
         this.wsConnected = false;
         this.createWsClient();
-        EventEmitter.call(this);
+        events_1.EventEmitter.call(this);
     }
     connect() {
         this.ws.open();
         this.startMsgsTimeoutCheck();
     }
     disconnect() {
-        this.ws.close();
+        this.ws.destroy();
         this.stopMsgsTimeoutCheck();
     }
     declareEvent(eventDeclaration) {
@@ -70,21 +70,21 @@ class CamScripterAPICameraEventsGenerator extends EventEmitter {
             protocol: 'camera-events',
         };
         this.ws = new WsClient_1.WsClient(options);
-        this.ws.on('open', () => {
+        this.ws.onOpen = () => {
             this.wsConnected = true;
             this.emit('open');
-        });
-        this.ws.on('message', (msgData) => this.incomingWsMessageHandler(msgData));
-        this.ws.on('error', (error) => {
+        };
+        this.ws.onMessage = (data) => this.incomingWsMessageHandler(data.toString());
+        this.ws.onError = (error) => {
             this.reportErr(error);
-        });
-        this.ws.on('close', () => {
+        };
+        this.ws.onClose = () => {
             this.wsConnected = false;
             this.reportClose();
-        });
+        };
     }
     incomingWsMessageHandler(msgData) {
-        const dataJSON = JSON.parse(msgData.toString());
+        const dataJSON = JSON.parse(msgData);
         let errorResponse;
         if ('error' in dataJSON) {
             errorResponse = dataJSON;

package/cjs/node/DefaultClient.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="node" />
-import { IClient, HttpOptions, TParameters } from '../internal/common';
-export declare class DefaultClient implements IClient {
+/// <reference types="node" />
+import { IClient, HttpOptions, TGetParams, TPostParams } from '../internal/types';
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
+export declare class DefaultClient implements IClient<UndiciResponse, UndiciFormData | Buffer> {
     private tls;
     private ip;
     private port;
@@ -8,8 +10,7 @@ export declare class DefaultClient implements IClient {
     private pass;
     private httpRequestSender;
     constructor(opt?: HttpOptions);
-    get url(): string;
-    get(path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
-    post(path: string, data: string | FormData | Buffer, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
+    get(params: TGetParams): Promise<UndiciResponse>;
+    post(params: TPostParams<UndiciFormData | Buffer>): Promise<UndiciResponse>;
     private getBaseConnectionParams;
 }

package/cjs/node/DefaultClient.js

@@ -25,29 +25,27 @@ class DefaultClient {
         }
         this.httpRequestSender = new HttpRequestSender_1.HttpRequestSender(agentOptions);
     }
-    get url() {
-        return `${this.tls ? 'https' : 'http'}://${this.user}:${this.pass}@${this.ip}:${this.port}`;
-    }
-    async get(path, parameters = {}, headers) {
-        const options = this.getBaseConnectionParams('GET', path, parameters);
-        options.headers = headers;
+    get(params) {
+        const { path, parameters, headers, timeout } = params;
+        const options = this.getBaseConnectionParams('GET', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options);
     }
-    async post(path, data, parameters = {}, headers) {
-        const options = this.getBaseConnectionParams('POST', path, parameters);
-        options.headers = headers;
+    post(params) {
+        const { path, data, parameters, headers, timeout } = params;
+        const options = this.getBaseConnectionParams('POST', path, parameters, headers, timeout);
         return this.httpRequestSender.sendRequest(options, data);
     }
-    getBaseConnectionParams(method, path, params) {
-        const pathName = (0, utils_1.addParametersToPath)(path, params);
+    getBaseConnectionParams(method, path, params, headers, timeout) {
         return {
             method: method,
             protocol: this.tls ? 'https:' : 'http:',
             host: this.ip,
             port: this.port,
-            path: pathName,
+            path: (0, utils_1.addParametersToPath)(path, params),
             user: this.user,
             pass: this.pass,
+            headers,
+            timeout,
         };
     }
 }

package/cjs/{internal → node}/Digest.js

@@ -1,7 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Digest = void 0;
-const crypto = require("crypto");
+const crypto = __importStar(require("crypto"));
 class Digest {
     nonceCount = 1;
     getAuthHeader(user, pass, method, uri, wwwAuthenticateHeader) {

package/cjs/node/Digest.test.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Digest_1 = require("./Digest");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)('Digest', () => {
+    (0, globals_1.describe)('getAuthHeader', () => {
+        (0, globals_1.test)('Checks, that Digest.getAuthHeader() returns correct value.', () => {
+            const testString = 'Digest realm="testrealm@host.com", qop="auth,auth-int", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", opaque="5ccc069c403ebaf9f0171e9517f40e41"';
+            const value = 'Digest username="root",realm="testrealm@host.com",nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",uri="www.cz",response="63f54af3ce5cf193a7435d5c68625472",qop=auth,nc=00000001,cnonce="162d50aa594e9648"';
+            (0, globals_1.expect)(new Digest_1.Digest().getAuthHeader('root', 'pass', 'GET', 'www.cz', testString)).toBe(value);
+        });
+    });
+});

package/cjs/node/HttpRequestSender.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
 export type HttpRequestOptions = {
     method?: string;

package/cjs/node/HttpRequestSender.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpRequestSender = void 0;
-const Digest_1 = require("../internal/Digest");
+const Digest_1 = require("./Digest");
 const undici_1 = require("undici");
 class HttpRequestSender {
     agent;
@@ -11,8 +11,18 @@ class HttpRequestSender {
             connect: { rejectUnauthorized: agentOptions?.rejectUnaurhorized, keepAlive: agentOptions?.keepAlive },
         });
     }
-    sendRequest(options, postData) {
-        return this.sendRequestWithAuth(options, postData);
+    async sendRequest(options, postData) {
+        const stackHolder = { stack: '' };
+        Error.captureStackTrace(stackHolder, this.sendRequest);
+        try {
+            return await this.sendRequestWithAuth(options, postData);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                err.stack = `${err.stack}\nCaptured at:\n${stackHolder.stack}`;
+            }
+            throw err;
+        }
     }
     async sendRequestWithAuth(options, postData, wwwAuthenticateHeader) {
         options.timeout ??= 10000;
@@ -82,7 +92,7 @@ class HttpRequestSender {
             return authData.digest.getAuthHeader(options.user, options.pass, options.method ?? 'GET', options.path, authData.wwwAuthenticateHeader);
         }
         else {
-            return `Basic ${btoa(options.user + ':' + options.pass)}`;
+            return `Basic ${Buffer.from(`${options.user}:${options.pass}`).toString('base64')}`;
         }
     }
 }

package/cjs/node/HttpServer.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import * as http from 'http';
-import * as EventEmitter from 'events';
+import { EventEmitter } from 'events';
 export type HttpServerOptions = {
     host?: string;
     port?: number;

package/cjs/node/HttpServer.js

@@ -1,12 +1,35 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpServer = void 0;
-const http = require("http");
-const url = require("url");
-const fs = require("fs");
-const path = require("path");
-const EventEmitter = require("events");
-class HttpServer extends EventEmitter {
+const http = __importStar(require("http"));
+const url = __importStar(require("url"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const events_1 = require("events");
+class HttpServer extends events_1.EventEmitter {
     host;
     port;
     registeredPaths;

package/cjs/node/TimeZoneDaemon.d.ts

@@ -0,0 +1,6 @@
+export declare class TimeZoneDaemon {
+    private checkTimer?;
+    constructor(checkInterval?: number);
+    stop(): void;
+    private checkAndUpdateTimeZone;
+}

package/cjs/node/TimeZoneDaemon.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeZoneDaemon = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+class TimeZoneDaemon {
+    checkTimer;
+    constructor(checkInterval = 60000) {
+        this.checkTimer = setInterval(() => this.checkAndUpdateTimeZone(), checkInterval);
+    }
+    stop() {
+        clearInterval(this.checkTimer);
+    }
+    async checkAndUpdateTimeZone() {
+        try {
+            const { stdout } = await execPromise('timedatectl show -p Timezone --value');
+            const systemTimezone = stdout.toString().trim();
+            const nodeTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            if (systemTimezone !== nodeTimezone) {
+                process.env.TZ = systemTimezone;
+            }
+        }
+        catch (error) {
+            console.error('Error checking/updating timezone:', error);
+        }
+    }
+}
+exports.TimeZoneDaemon = TimeZoneDaemon;

package/cjs/node/VapixEvents.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { Options } from '../internal/types';
+export declare class VapixEvents extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private ws;
+    constructor(options?: Options);
+    connect(): void;
+    disconnect(): void;
+    private createWsClient;
+    private isReservedEventName;
+}

package/cjs/{VapixEvents.js → node/VapixEvents.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VapixEvents = void 0;
 const eventemitter2_1 = require("eventemitter2");
-const WsClient_1 = require("./node/WsClient");
+const WsClient_1 = require("./WsClient");
 class VapixEvents extends eventemitter2_1.EventEmitter2 {
     tls;
     tlsInsecure;
@@ -26,7 +26,7 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
         this.ws.open();
     }
     disconnect() {
-        this.ws.close();
+        this.ws.destroy();
     }
     createWsClient() {
         const options = {
@@ -39,7 +39,7 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
             address: '/vapix/ws-data-stream?sources=events',
         };
         this.ws = new WsClient_1.WsClient(options);
-        this.ws.on('open', () => {
+        this.ws.onOpen = () => {
             const topics = [];
             const eventNames = this.eventNames();
             for (const eventName of eventNames) {
@@ -58,8 +58,8 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
                 },
             };
             this.ws.send(JSON.stringify(topicFilter));
-        });
-        this.ws.on('message', (data) => {
+        };
+        this.ws.onMessage = (data) => {
             const dataJSON = JSON.parse(data.toString());
             if (dataJSON.method === 'events:configure') {
                 if (dataJSON.error === undefined) {
@@ -73,13 +73,13 @@ class VapixEvents extends eventemitter2_1.EventEmitter2 {
             }
             const eventName = dataJSON.params.notification.topic;
             this.emit(eventName, dataJSON);
-        });
-        this.ws.on('error', (error) => {
+        };
+        this.ws.onError = (error) => {
             this.emit('error', error);
-        });
-        this.ws.on('close', () => {
+        };
+        this.ws.onClose = () => {
             this.emit('close');
-        });
+        };
     }
     isReservedEventName(eventName) {
         return eventName === 'open' || eventName === 'close' || eventName === 'error';

package/cjs/node/WsClient.d.ts

@@ -1,24 +1,11 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import * as EventEmitter from 'events';
-import { WsOptions } from '../internal/common';
-export type WsClientOptions = WsOptions & {
+import { IWsClient, Options } from '../internal/types';
+export type WsClientOptions = Options & {
     address: string;
     headers?: Record<string, string>;
     pingInterval?: number;
     protocol?: string;
 };
-export interface WsClient {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'message', listener: (data: Buffer) => void): this;
-    on(event: 'error', listener: (err: Error) => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'message', data: Buffer): boolean;
-    emit(event: 'error', err: Error): boolean;
-}
-export declare class WsClient extends EventEmitter {
+export declare class WsClient implements IWsClient {
     private user;
     private pass;
     private address;
@@ -32,8 +19,12 @@ export declare class WsClient extends EventEmitter {
     private isClosed;
     constructor(options: WsClientOptions);
     open(wwwAuthenticateHeader?: string): void;
-    send(data: Buffer | string): void;
-    close(): void;
+    onMessage: (_: ArrayBuffer | string) => void;
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send(data: ArrayBuffer | string): void;
+    destroy(): void;
     reconnect(): void;
     private closeWsConnection;
 }

package/cjs/node/WsClient.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WsClient = void 0;
-const EventEmitter = require("events");
-const WebSocket = require("ws");
-const Digest_1 = require("../internal/Digest");
-class WsClient extends EventEmitter {
+const ws_1 = require("ws");
+const Digest_1 = require("./Digest");
+class WsClient {
     user;
     pass;
     address;
@@ -17,7 +16,6 @@ class WsClient extends EventEmitter {
     ws;
     isClosed = false;
     constructor(options) {
-        super();
         const tls = options.tls ?? false;
         const tlsInsecure = options.tlsInsecure ?? false;
         const ip = options.ip ?? '127.0.0.1';
@@ -42,17 +40,17 @@ class WsClient extends EventEmitter {
             }
             this.isClosed = false;
             if (this.protocol === undefined) {
-                this.ws = new WebSocket(this.address, this.wsOptions);
+                this.ws = new ws_1.WebSocket(this.address, this.wsOptions);
             }
             else {
-                this.ws = new WebSocket(this.address, this.protocol, this.wsOptions);
+                this.ws = new ws_1.WebSocket(this.address, this.protocol, this.wsOptions);
             }
             this.ws.binaryType = 'arraybuffer';
             this.isAlive = true;
-            this.pingTimer = setInterval(async () => {
-                if ((this.ws && this.ws.readyState !== WebSocket.OPEN) || this.isAlive === false) {
-                    this.emit('error', new Error('Connection timeout'));
-                    await this.closeWsConnection();
+            this.pingTimer = setInterval(() => {
+                if ((this.ws && this.ws.readyState !== ws_1.WebSocket.OPEN) || this.isAlive === false) {
+                    this.onError(new Error('Connection timeout'));
+                    this.closeWsConnection();
                 }
                 else {
                     this.isAlive = false;
@@ -75,23 +73,32 @@ class WsClient extends EventEmitter {
                     this.open(res.headers['www-authenticate']);
                 }
                 else {
-                    this.emit('error', new Error('Status code: ' + res.statusCode));
+                    this.onError(new Error('Status code: ' + res.statusCode));
                     this.closeWsConnection();
                 }
             });
-            this.ws.on('open', () => this.emit('open'));
-            this.ws.on('message', (data) => this.emit('message', data));
+            this.ws.on('open', () => this.onOpen());
+            this.ws.on('message', (data, isBinary) => {
+                const message = isBinary ? data : data.toString();
+                this.onMessage(message);
+            });
             this.ws.on('error', (error) => {
-                this.emit('error', error);
+                this.onError(error);
                 this.closeWsConnection();
             });
             this.ws.on('close', () => this.closeWsConnection());
         }
         catch (error) {
-            this.emit('error', error instanceof Error ? error : new Error('Unknown error'));
+            this.onError(error instanceof Error ? error : new Error('Unknown error'));
             this.closeWsConnection();
         }
     }
+    onMessage = (_) => { };
+    onOpen = () => { };
+    onClose = () => { };
+    onError = (error) => {
+        console.error(error);
+    };
     send(data) {
         if (this.ws === undefined) {
             throw new Error("This websocket hasn't been opened yet.");
@@ -100,7 +107,7 @@ class WsClient extends EventEmitter {
             this.ws.send(data);
         }
     }
-    close() {
+    destroy() {
         if (this.isClosed) {
             return;
         }
@@ -122,15 +129,15 @@ class WsClient extends EventEmitter {
             }
             wsCopy.removeAllListeners();
             wsCopy.on('error', () => { });
-            if (wsCopy.readyState !== WebSocket.CLOSING && wsCopy.readyState !== WebSocket.CLOSED) {
+            if (wsCopy.readyState !== ws_1.WebSocket.CLOSING && wsCopy.readyState !== ws_1.WebSocket.CLOSED) {
                 wsCopy.close();
             }
             setTimeout(() => {
-                if (wsCopy.readyState !== WebSocket.CLOSED) {
+                if (wsCopy.readyState !== ws_1.WebSocket.CLOSED) {
                     wsCopy.terminate();
                 }
             }, 5000);
-            this.emit('close');
+            this.onClose();
         }
         catch (err) {
             console.error(err);

package/cjs/node/events/AxisCameraStationEvents.d.ts

@@ -0,0 +1,12 @@
+import { HttpOptions } from '../../internal/types';
+import { ProxyClient } from '../../internal/ProxyClient';
+import { THttpRequestOptions, TProxyParams } from '../../types/common';
+import { DefaultClient } from '../DefaultClient';
+export declare class AxisCameraStationEvents {
+    private sourceKey;
+    private client;
+    constructor(clientOptions: HttpOptions, sourceKey: string);
+    getClient(proxyParams?: TProxyParams): DefaultClient | ProxyClient<DefaultClient>;
+    sendEvent(data: Record<string, string>, eventType: string, options?: THttpRequestOptions): Promise<void>;
+    private getDate;
+}

package/cjs/node/events/AxisCameraStationEvents.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxisCameraStationEvents = void 0;
+const utils_1 = require("../../internal/utils");
+const ProxyClient_1 = require("../../internal/ProxyClient");
+const DefaultClient_1 = require("../DefaultClient");
+class AxisCameraStationEvents {
+    sourceKey;
+    client;
+    constructor(clientOptions, sourceKey) {
+        this.sourceKey = sourceKey;
+        this.client = new DefaultClient_1.DefaultClient(clientOptions);
+    }
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async sendEvent(data, eventType, options) {
+        const dateString = this.getDate();
+        const event = {
+            addExternalDataRequest: {
+                occurrenceTime: dateString,
+                source: this.sourceKey,
+                externalDataType: eventType,
+                data: data,
+            },
+        };
+        const eventData = JSON.stringify(event);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path: '/Acs/Api/ExternalDataFacade/AddExternalData',
+            data: eventData,
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': eventData.length.toString(),
+            },
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            throw new Error(`ACS status code: ${res.status}`);
+        }
+    }
+    getDate() {
+        const date = new Date();
+        const year = date.getUTCFullYear();
+        const month = (0, utils_1.pad)(date.getUTCMonth() + 1, 2);
+        const day = (0, utils_1.pad)(date.getUTCDate(), 2);
+        const hours = (0, utils_1.pad)(date.getUTCHours(), 2);
+        const minutes = (0, utils_1.pad)(date.getUTCMinutes(), 2);
+        const seconds = (0, utils_1.pad)(date.getUTCSeconds(), 2);
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+    }
+}
+exports.AxisCameraStationEvents = AxisCameraStationEvents;

package/cjs/node/events/GenetecAgent.d.ts

@@ -0,0 +1,16 @@
+import { GenetecAgentOptions, TCameraDetail, TCameraGuidsResponse, TParams } from '../../types/GenetecAgent';
+export declare class GenetecAgent {
+    private settings;
+    private baseUrl;
+    private credentials;
+    constructor(options?: GenetecAgentOptions);
+    checkConnection(): Promise<void>;
+    getAllCameraGuids(): Promise<TCameraGuidsResponse>;
+    getCameraDetails(guids: {
+        Guid: string;
+    }[], parameters: TParams): Promise<TCameraDetail[]>;
+    sendBookmark(guids: string[], bookmarkText: string): Promise<void>;
+    private getRequestOptions;
+    private getTimeStamp;
+    private fetchWithTimeout;
+}