camstreamerlib 3.2.2 → 3.2.4

package/CamOverlayAPI.d.ts

@@ -6,32 +6,43 @@ export type TField = {
     text: string;
     color?: string;
 };
-export type TService = {
-    id: number;
-    enabled: number;
-    schedule: string;
-    name: string;
-    identifier: string;
-    cameraList: number[];
-};
+export type TService = Record<string, any>;
 export type TServiceList = {
     services: TService[];
 };
+export type TNetworkCameraList = {
+    name: string;
+    ip: string;
+}[];
+export type TImage = {
+    name: string;
+    path: string;
+    storage: string;
+};
 export declare enum ImageType {
     PNG = 0,
     JPEG = 1
 }
+export type TCoordinates = 'top_left' | 'top_right' | 'top' | 'bottom_left' | 'bottom_right' | 'bottom' | 'left' | 'right' | 'center' | '';
 export declare class CamOverlayAPI {
     private client;
     constructor(options?: CamOverlayOptions | IClient);
-    updateCGText(serviceID: number, fields: TField[]): Promise<void>;
-    updateCGImagePos(serviceID: number, coordinates?: string, x?: number, y?: number): Promise<void>;
-    updateCGImage(serviceID: number, path: string, coordinates?: string, x?: number, y?: number): Promise<void>;
+    checkCameraTime(): Promise<boolean>;
+    listImages(): Promise<TImage[]>;
+    uploadImage(file: Buffer, fileName: string): Promise<void>;
+    getNetworkCameraList(): Promise<TNetworkCameraList>;
     updateInfoticker(serviceID: number, text: string): Promise<void>;
     setEnabled(serviceID: number, enabled: boolean): Promise<void>;
     isEnabled(serviceID: number): Promise<boolean>;
+    getSingleService(serviceId: number): Promise<TService>;
+    getServices(): Promise<TService[]>;
+    updateSingleService(serviceId: number, serviceJson: TService): Promise<void>;
     updateServices(servicesJson: TServiceList): Promise<void>;
-    updateCGImageFromData(serviceID: number, imageType: ImageType, imageData: Buffer, coordinates?: string, x?: number, y?: number): Promise<void>;
-    promiseCGUpdate(serviceID: number, action: string, params: string, contentType?: string, data?: Buffer): Promise<void>;
-    private formCoordinates;
+    updateCGText(serviceID: number, fields: TField[]): Promise<void>;
+    updateCGImagePos(serviceID: number, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    updateCGImage(serviceID: number, path: string, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    updateCGImageFromData(serviceID: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    private promiseCGUpdate;
+    private get;
+    private post;
 }

package/CamOverlayAPI.js

@@ -26,32 +26,39 @@ class CamOverlayAPI {
             this.client = new DefaultAgent_1.DefaultAgent(options);
         }
     }
-    updateCGText(serviceID, fields) {
-        let field_specs = '';
-        for (const 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(serviceID, 'update_text', field_specs);
+    checkCameraTime() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cameraTime = yield this.get('/local/camoverlay/api/camera_time.cgi');
+            return cameraTime.state;
+        });
     }
-    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
-        const coord = this.formCoordinates(coordinates, x, y);
-        return this.promiseCGUpdate(serviceID, 'update_image', coord);
+    listImages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const images = yield this.get('/local/camoverlay/api/upload_image.cgi?action=list');
+            return images.list;
+        });
     }
-    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
-        const coord = this.formCoordinates(coordinates, x, y);
-        const update = `&image=${path}`;
-        return this.promiseCGUpdate(serviceID, 'update_image', update + coord);
+    uploadImage(file, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formData = new FormData();
+            formData.append('target', 'SD0');
+            formData.append('uploadedFile[]', file, fileName);
+            const path = '/local/camoverlay/api/upload_image.cgi?action=upload';
+            yield this.post(path, formData);
+        });
+    }
+    getNetworkCameraList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.get('/local/camoverlay/api/network_camera_list.cgi');
+            return response.camera_list;
+        });
     }
     updateInfoticker(serviceID, text) {
         return __awaiter(this, void 0, void 0, function* () {
             const path = `/local/camoverlay/api/infoticker.cgi?service_id=${serviceID}&text=${text}`;
             const res = yield this.client.get(path);
             if (!res.ok) {
-                throw new Error(JSON.stringify(res));
+                throw new Error(yield (0, common_1.responseStringify)(res));
             }
         });
     }
@@ -60,7 +67,7 @@ class CamOverlayAPI {
             const path = `/local/camoverlay/api/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`;
             const res = yield this.client.post(path, '');
             if (!res.ok) {
-                throw new Error(JSON.stringify(res));
+                throw new Error(yield (0, common_1.responseStringify)(res));
             }
         });
     }
@@ -78,39 +85,110 @@ class CamOverlayAPI {
                 throw new Error('Service not found.');
             }
             else {
-                throw new Error(JSON.stringify(res));
+                throw new Error(yield (0, common_1.responseStringify)(res));
             }
         });
     }
+    getSingleService(serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.get('/local/camoverlay/api/services.cgi', { action: 'get', service_id: serviceId.toString() });
+        });
+    }
+    getServices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const serviceList = yield this.get('/local/camoverlay/api/services.cgi?action=get');
+            return serviceList.services;
+        });
+    }
+    updateSingleService(serviceId, serviceJson) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = '/local/camoverlay/api/services.cgi';
+            yield this.post(path, JSON.stringify(serviceJson), {
+                action: 'set',
+                service_id: serviceId.toString(),
+            });
+        });
+    }
     updateServices(servicesJson) {
         return __awaiter(this, void 0, void 0, function* () {
             const path = '/local/camoverlay/api/services.cgi?action=set';
             const res = yield this.client.post(path, JSON.stringify(servicesJson));
             if (!res.ok) {
-                throw new Error(JSON.stringify(res));
+                throw new Error(yield (0, common_1.responseStringify)(res));
             }
         });
     }
+    updateCGText(serviceID, fields) {
+        const params = {};
+        for (const field of fields) {
+            const name = field.field_name;
+            params[name] = field.text;
+            if (field.color !== undefined) {
+                params[`${name}_color`] = field.color;
+            }
+        }
+        return this.promiseCGUpdate(serviceID, 'update_text', params);
+    }
+    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
+        const params = {
+            coord_system: coordinates,
+            pos_x: x,
+            pos_y: y,
+        };
+        return this.promiseCGUpdate(serviceID, 'update_image', params);
+    }
+    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
+        const params = {
+            coord_system: coordinates,
+            pos_x: x,
+            pos_y: y,
+            image: path,
+        };
+        return this.promiseCGUpdate(serviceID, 'update_image', params);
+    }
     updateCGImageFromData(serviceID, imageType, imageData, coordinates = '', x = 0, y = 0) {
-        const coord = this.formCoordinates(coordinates, x, y);
         const contentType = imageType === ImageType.PNG ? 'image/png' : 'image/jpeg';
-        return this.promiseCGUpdate(serviceID, 'update_image', coord, contentType, imageData);
+        const params = {
+            coord_system: coordinates,
+            pos_x: x,
+            pos_y: y,
+        };
+        return this.promiseCGUpdate(serviceID, 'update_image', params, contentType, imageData);
     }
-    promiseCGUpdate(serviceID, action, params, contentType, data) {
+    promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const path = `/local/camoverlay/api/customGraphics.cgi?action=${action}&service_id=${serviceID}${params}`;
+            const path = `/local/camoverlay/api/customGraphics.cgi`;
             let headers = {};
             if (contentType !== undefined && data) {
                 headers = { 'Content-Type': contentType };
             }
-            const res = yield this.client.post(path, data !== null && data !== void 0 ? data : '', {}, headers);
+            const res = yield this.client.post(path, data !== null && data !== void 0 ? data : '', Object.assign({ action: action, service_id: serviceID.toString() }, params), headers);
             if (!res.ok) {
-                throw new Error(JSON.stringify(res));
+                throw new Error(yield (0, common_1.responseStringify)(res));
             }
         });
     }
-    formCoordinates(coordinates, x, y) {
-        return coordinates !== '' ? `&coord_system=${coordinates}&pos_x=${x}&pos_y=${y}` : '';
+    get(path, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.get(path, params);
+            if (res.ok) {
+                return yield res.json();
+            }
+            else {
+                throw new Error(yield (0, common_1.responseStringify)(res));
+            }
+        });
+    }
+    post(path, data, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.post(path, data, params);
+            if (res.ok) {
+                return yield res.json();
+            }
+            else {
+                throw new Error(yield (0, common_1.responseStringify)(res));
+            }
+        });
     }
 }
 exports.CamOverlayAPI = CamOverlayAPI;

package/CamOverlayDrawingAPI.d.ts

@@ -34,6 +34,16 @@ export type TServiceList = {
 export type TAlign = 'A_RIGHT' | 'A_LEFT' | 'A_CENTER';
 export type TextFit = 'TFM_SCALE' | 'TFM_TRUNCATE' | 'TFM_OVERFLOW';
 export type TWriteTextParams = [string, string, number, number, number, number, TAlign, TextFit?];
+export interface CamOverlayDrawingAPI {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'message', listener: (msg: string) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: 'message', msg: string): boolean;
+}
 export declare class CamOverlayDrawingAPI extends EventEmitter {
     private tls;
     private tlsInsecure;

package/CamOverlayDrawingAPI.js

@@ -73,7 +73,7 @@ class CamOverlayDrawingAPI extends EventEmitter {
         });
     }
     removeImage() {
-        return this.sendMessage({ command: 'remove_image_v2' });
+        return this.sendMessage({ command: 'remove_image_v2', params: [] });
     }
     createWsClient() {
         const options = {

package/CamScripterAPICameraEventsGenerator.d.ts

@@ -35,6 +35,14 @@ export type TResponse = {
     call_id: number;
     message: string;
 };
+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;

package/CamStreamerAPI.d.ts

@@ -28,8 +28,11 @@ 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: TStreamAttributes): Promise<void>;
     setStreamParameter(streamID: string, paramName: string, value: string): Promise<void>;
     isStreaming(streamID: string): Promise<boolean>;
-    get(path: string): Promise<any>;
+    deleteStream(streamID: string): Promise<void>;
+    private get;
 }

package/CamStreamerAPI.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamStreamerAPI = void 0;
 const common_1 = require("./internal/common");
@@ -27,12 +38,24 @@ class CamStreamerAPI {
             return streamListRes.data;
         });
     }
+    getStream(streamID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stream = yield this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
+            return stream.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];
         });
     }
+    setStream(streamID, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { streamDelay, startTime, stopTime } = params, rest = __rest(params, ["streamDelay", "startTime", "stopTime"]);
+            yield this.get('/local/camstreamer/stream/set.cgi', Object.assign({ stream_id: streamID, streamDelay: streamDelay !== null && streamDelay !== void 0 ? streamDelay : '', startTime: startTime !== null && startTime !== void 0 ? startTime : 'null', stopTime: stopTime !== null && stopTime !== void 0 ? stopTime : 'null' }, rest));
+        });
+    }
     setStreamParameter(streamID, paramName, value) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.get(`/local/camstreamer/stream/set.cgi?stream_id=${streamID}&${paramName}=${value}`);
@@ -44,14 +67,19 @@ class CamStreamerAPI {
             return response.data.is_streaming === 1;
         });
     }
-    get(path) {
+    deleteStream(streamID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.get('/local/camstreamer/stream/remove.cgi', { stream_id: streamID });
+        });
+    }
+    get(path, parameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.client.get(path);
+            const res = yield this.client.get(path, parameters);
             if (res.ok) {
                 return yield res.json();
             }
             else {
-                throw new Error(JSON.stringify(res));
+                throw new Error(yield (0, common_1.responseStringify)(res));
             }
         });
     }

package/CamSwitcherAPI.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-import * as EventEmitter from 'events';
 import { HttpOptions, IClient } from './internal/common';
 export type CamSwitcherAPIOptions = HttpOptions;
 export type TStreamInfo = {
@@ -21,14 +20,16 @@ export type TPlaylistInfo = {
     sortIndexOverview: number;
     stream_list: TStreamInfo[];
 };
+export type TPlaylistList = Record<string, TPlaylistInfo>;
 export type TClipInfo = {
     niceName: string;
     channel: string;
     keyboard: object;
     sortIndexOverview: number;
 };
-export type TPlaylistList = Record<string, TPlaylistInfo>;
 export type TClipList = Record<string, TClipInfo>;
+export type TApiClipType = 'audio' | 'video';
+export type TClipStorage = 'SD_DISK' | 'FLASH';
 export type TPlaylistQueue = {
     playlist_queue_list: string[];
 };
@@ -37,16 +38,44 @@ export type TOutputInfo = {
     ws: string;
     ws_initial_message: string;
 };
-export declare class CamSwitcherAPI extends EventEmitter {
+export type TSilenceChannel = 'mono' | 'stereo';
+export type TAvailableCameraList = {
+    camera_list: {
+        name: string;
+        ip: string;
+    }[];
+};
+export type TStorageInfo = {
+    storage: TClipStorage;
+    writable: boolean;
+    size: number;
+    available: number;
+};
+declare const cgiNames: {
+    camera: string;
+    audio: string;
+    playlist: string;
+    clip: string;
+    tracker: string;
+};
+export type TSourceType = keyof typeof cgiNames;
+export declare class CamSwitcherAPI {
     private client;
     constructor(options?: CamSwitcherAPIOptions | IClient);
+    generateSilence(sampleRate: number, channels: TSilenceChannel): Promise<void>;
+    getIpListFromNetworkCheck(): Promise<TAvailableCameraList>;
+    getMaxFps(source: number): Promise<number>;
+    getStorageInfo(): Promise<TStorageInfo[]>;
+    getOutputInfo(): Promise<TOutputInfo>;
     getPlaylistList(): Promise<TPlaylistList>;
-    getClipList(): Promise<TClipList>;
     playlistSwitch(playlistName: string): Promise<void>;
-    playlistQueueList(): Promise<TPlaylistQueue>;
-    playlistQueueClear(): Promise<void>;
     playlistQueuePush(playlistName: string): Promise<void>;
+    playlistQueueClear(): Promise<void>;
+    playlistQueueList(): Promise<TPlaylistQueue>;
     playlistQueuePlayNext(): Promise<void>;
-    getOutputInfo(): Promise<TOutputInfo>;
-    get(path: string): Promise<any>;
+    getClipList(): Promise<TClipList>;
+    addNewClip(file: Buffer, clipType: TApiClipType, storage: TClipStorage, id: string, fileName: string): Promise<void>;
+    removeClip(id: string, storage: TClipStorage): Promise<{}>;
+    private get;
 }
+export {};

package/CamSwitcherAPI.js

@@ -10,60 +10,101 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamSwitcherAPI = void 0;
-const EventEmitter = require("events");
 const DefaultAgent_1 = require("./DefaultAgent");
 const common_1 = require("./internal/common");
-class CamSwitcherAPI extends EventEmitter {
+const cgiNames = {
+    camera: 'streams',
+    audio: 'audios',
+    playlist: 'playlists',
+    clip: 'clips',
+    tracker: 'trackers',
+};
+class CamSwitcherAPI {
     constructor(options = {}) {
-        super();
         if ((0, common_1.isClient)(options)) {
             this.client = options;
         }
         else {
             this.client = new DefaultAgent_1.DefaultAgent(options);
         }
-        EventEmitter.call(this);
+    }
+    generateSilence(sampleRate, channels) {
+        return this.get('/local/camswitcher/generate_silence.cgi', { sample_rate: sampleRate.toString(), channels });
+    }
+    getIpListFromNetworkCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.get('/local/camswitcher/network_camera_list.cgi')).data;
+        });
+    }
+    getMaxFps(source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.get('/local/camswitcher/get_max_framerate.cgi', { video_source: source.toString() })).data;
+        });
+    }
+    getStorageInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.get('/local/camswitcher/get_storage.cgi')).data;
+        });
+    }
+    getOutputInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.get('/local/camswitcher/output_info.cgi')).data;
+        });
     }
     getPlaylistList() {
         return this.get('/local/camswitcher/playlists.cgi?action=get');
     }
-    getClipList() {
-        return this.get('/local/camswitcher/clips.cgi?action=get');
-    }
     playlistSwitch(playlistName) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.get(`/local/camswitcher/playlist_switch.cgi?playlist_name=${playlistName}`);
         });
     }
-    playlistQueueList() {
-        return this.get('/local/camswitcher/playlist_queue_list.cgi');
+    playlistQueuePush(playlistName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.get(`/local/camswitcher/playlist_queue_push.cgi?playlist_name=${playlistName}`);
+        });
     }
     playlistQueueClear() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.get('/local/camswitcher/playlist_queue_clear.cgi');
         });
     }
-    playlistQueuePush(playlistName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.get(`/local/camswitcher/playlist_queue_push.cgi?playlist_name=${playlistName}`);
-        });
+    playlistQueueList() {
+        return this.get('/local/camswitcher/playlist_queue_list.cgi');
     }
     playlistQueuePlayNext() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.get('/local/camswitcher/playlist_queue_play_next.cgi');
         });
     }
-    getOutputInfo() {
-        return this.get('/local/camswitcher/output_info.cgi');
+    getClipList() {
+        return this.get('/local/camswitcher/clips.cgi?action=get');
+    }
+    addNewClip(file, clipType, storage, id, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formData = new FormData();
+            formData.append('clip_name', id);
+            formData.append('clip_type', clipType);
+            formData.append('file', file, fileName);
+            const path = `/local/camswitcher/clip_upload.cgi?storage=${storage}`;
+            const res = yield this.client.post(path, formData);
+            const output = (yield res.json());
+            if (output.status !== 200) {
+                throw new Error('Error on camera: ' + output.message);
+            }
+        });
+    }
+    removeClip(id, storage) {
+        return this.get(`/local/camswitcher/clip_remove.cgi`, { clip_name: id, storage });
     }
-    get(path) {
+    get(path, parameters = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.client.get(path);
+            const res = yield this.client.get(path, parameters);
             if (res.ok) {
                 return yield res.json();
             }
             else {
-                throw new Error(JSON.stringify(res));
+                throw new Error(yield (0, common_1.responseStringify)(res));
             }
         });
     }

package/CamSwitcherEvents.d.ts

@@ -2,6 +2,22 @@
 import * as EventEmitter from 'events';
 import { HttpOptions } from './internal/common';
 export type CamSwitcherEventsOptions = HttpOptions;
+export type TEvent = {
+    type: string;
+    date: Record<string, string | number | boolean> & {
+        type: string;
+    };
+};
+export interface CamSwitcherEvents {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'event', listener: (data: TEvent) => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'event', data: TEvent): boolean;
+    emit(event: 'error', err: Error): boolean;
+}
 export declare class CamSwitcherEvents extends EventEmitter {
     private tls;
     private tlsInsecure;
@@ -14,6 +30,7 @@ export declare class CamSwitcherEvents extends EventEmitter {
     constructor(options?: CamSwitcherEventsOptions);
     connect(): void;
     disconnect(): void;
+    resendInitData(): void;
     private createWsClient;
     private get;
 }

package/CamSwitcherEvents.js

@@ -33,6 +33,12 @@ class CamSwitcherEvents extends EventEmitter {
     disconnect() {
         this.ws.close();
     }
+    resendInitData() {
+        const request = {
+            command: 'sendInitData',
+        };
+        this.ws.send(JSON.stringify(request));
+    }
     createWsClient() {
         const options = {
             ip: this.ip,
@@ -49,21 +55,28 @@ class CamSwitcherEvents extends EventEmitter {
             try {
                 const token = yield this.get('/local/camswitcher/ws_authorization.cgi');
                 this.ws.send(JSON.stringify({ authorization: token }));
-                this.emit('open');
             }
             catch (err) {
                 this.emit('error', err);
-                this.ws.close();
-                this.ws.open();
             }
         }));
         this.ws.on('message', (data) => {
             try {
                 const parsedData = JSON.parse(data.toString());
-                this.emit('event', parsedData);
+                if (parsedData.type === 'authorization') {
+                    if (parsedData.state === 'OK') {
+                        this.emit('open');
+                    }
+                    else {
+                        this.emit('error', new Error(data.toString()));
+                    }
+                }
+                else {
+                    this.emit('event', parsedData);
+                }
             }
             catch (err) {
-                console.error(err);
+                this.emit('error', err);
             }
         });
         this.ws.on('error', (err) => {

package/CameraVapix.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { WritableStream } from 'node:stream/web';
-import { EventEmitter2 as EventEmitter } from 'eventemitter2';
 import { HttpOptions, IClient } from './internal/common';
 export type CameraVapixOptions = HttpOptions;
 export type TApplicationList = {
@@ -41,20 +41,58 @@ export type TGuardTour = {
         waitTimeViewType: unknown;
     }[];
 };
-export declare class CameraVapix extends EventEmitter {
+export type TAudioSampleRates = {
+    sampleRate: number;
+    bitRates: number[];
+};
+export type TSDCardInfo = {
+    available: boolean;
+    totalSize: number;
+    freeSize: number;
+};
+export type TPtzOverview = Record<number, {
+    id: number;
+    name: string;
+}[]>;
+export type TCameraPTZItem = {
+    name: string;
+    id: number;
+    data: TCameraPTZItemData;
+};
+export type TCameraPTZItemData = {
+    pan?: number;
+    tilt?: number;
+    zoom?: number;
+};
+export declare class CameraVapix {
     private client;
     constructor(options?: CameraVapixOptions | IClient);
-    vapixGet(path: string): Promise<Response>;
-    vapixPost(path: string, data: string, contentType?: string): Promise<Response>;
+    vapixGet(path: string, parameters?: Record<string, string>): Promise<Response>;
+    vapixPost(path: string, data: string | Buffer | FormData, contentType?: string): Promise<Response>;
+    getCameraImage(camera: string, compression: string, resolution: string, outputStream: WritableStream): Promise<WritableStream<any>>;
+    getEventDeclarations(): Promise<string>;
+    getSupportedAudioSampleRate(): Promise<TAudioSampleRates[]>;
+    checkSdCard(): Promise<TSDCardInfo>;
+    downloadCameraReport(): Promise<Response>;
+    getMaxFps(channel: number): Promise<number>;
+    getTimezone(): Promise<string>;
+    getHeaders(): Promise<Record<string, string>>;
+    setHeaders(headers: Record<string, string>): Promise<Response>;
+    private parseGetParametrs;
     getParameterGroup(groupNames: string): Promise<Record<string, string>>;
     setParameter(params: Record<string, string>): Promise<Response>;
-    getPTZPresetList(channel: string): Promise<string[]>;
-    goToPreset(channel: number, presetName: string): Promise<Response>;
     getGuardTourList(): Promise<TGuardTour[]>;
     setGuardTourEnabled(gourTourID: string, enable: boolean): Promise<Response>;
+    private parsePtz;
+    private parseCameraPtzFromReq;
+    getPTZPresetList(channel: number): Promise<string[]>;
+    listPtzVideoSourceOverview(): Promise<TPtzOverview>;
+    goToPreset(channel: number, presetName: string): Promise<Response>;
+    getPtzPosition(camera: number): Promise<TCameraPTZItemData>;
     getInputState(port: number): Promise<boolean>;
     setOutputState(port: number, active: boolean): Promise<Response>;
     getApplicationList(): Promise<TApplication[]>;
-    getCameraImage(camera: string, compression: string, resolution: string, outputStream: WritableStream): Promise<WritableStream<any>>;
-    getEventDeclarations(): Promise<string>;
+    startApplication(applicationID: string): Promise<void>;
+    restartApplication(applicationID: string): Promise<void>;
+    stopApplication(applicationID: string): Promise<void>;
 }

package/CameraVapix.js

@@ -8,16 +8,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CameraVapix = void 0;
 const prettifyXml = require("prettify-xml");
 const xml2js_1 = require("xml2js");
-const eventemitter2_1 = require("eventemitter2");
 const common_1 = require("./internal/common");
 const DefaultAgent_1 = require("./DefaultAgent");
-class CameraVapix extends eventemitter2_1.EventEmitter2 {
+class CameraVapix {
     constructor(options = {}) {
-        super();
         if ((0, common_1.isClient)(options)) {
             this.client = options;
         }
@@ -25,8 +34,8 @@ class CameraVapix extends eventemitter2_1.EventEmitter2 {
             this.client = new DefaultAgent_1.DefaultAgent(options);
         }
     }
-    vapixGet(path) {
-        return this.client.get(path);
+    vapixGet(path, parameters) {
+        return this.client.get(path, parameters);
     }
     vapixPost(path, data, contentType) {
         let headers = {};
@@ -35,17 +44,174 @@ class CameraVapix extends eventemitter2_1.EventEmitter2 {
         }
         return this.client.post(path, data, {}, headers);
     }
+    getCameraImage(camera, compression, resolution, outputStream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = `/axis-cgi/jpg/image.cgi?resolution=${resolution}&compression=${compression}&camera=${camera}`;
+            const res = yield this.vapixGet(path);
+            if (res.body) {
+                void res.body.pipeTo(outputStream);
+            }
+            return outputStream;
+        });
+    }
+    getEventDeclarations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
+                '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
+                'xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
+                '<GetEventInstances xmlns="http://www.axis.com/vapix/ws/event1"/>' +
+                '</s:Body>' +
+                '</s:Envelope>';
+            const declarations = yield (yield this.vapixPost('/vapix/services', data, 'application/soap+xml')).text();
+            return prettifyXml(declarations);
+        });
+    }
+    getSupportedAudioSampleRate() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = '/axis-cgi/audio/streamingcapabilities.cgi';
+            const formData = { apiVersion: '1.0', method: 'list' };
+            const res = yield this.vapixPost(url, JSON.stringify(formData));
+            try {
+                const encoders = (yield res.json()).data.encoders;
+                const data = (_b = (_a = encoders.aac) !== null && _a !== void 0 ? _a : encoders.AAC) !== null && _b !== void 0 ? _b : [];
+                return data.map((item) => {
+                    return {
+                        sampleRate: item.sample_rate,
+                        bitRates: item.bit_rates,
+                    };
+                });
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    checkSdCard() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.vapixGet('/axis-cgi/disks/list.cgi', {
+                diskid: 'SD_DISK',
+            });
+            const result = yield (0, xml2js_1.parseStringPromise)(yield res.text(), {
+                ignoreAttrs: false,
+                mergeAttrs: true,
+                explicitArray: false,
+            });
+            const data = result.root.disks.disk;
+            return {
+                available: data.status === 'OK',
+                totalSize: parseInt(data.totalsize),
+                freeSize: parseInt(data.freesize),
+            };
+        });
+    }
+    downloadCameraReport() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.vapixGet('/axis-cgi/serverreport.cgi', { mode: 'text' });
+            if (res.ok) {
+                return res;
+            }
+            else {
+                throw new Error(yield (0, common_1.responseStringify)(res));
+            }
+        });
+    }
+    getMaxFps(channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = JSON.stringify({ apiVersion: '1.0', method: 'getCaptureModes' });
+            const res = yield this.vapixPost('/axis-cgi/capturemode.cgi', data);
+            if (!res.ok) {
+                throw new Error(yield (0, common_1.responseStringify)(res));
+            }
+            const response = (yield res.json());
+            const channels = response.data;
+            if (channels === undefined) {
+                throw new Error(`Malformed reply from camera`);
+            }
+            const channelData = channels.find((x) => x.channel === channel);
+            if (channelData === undefined) {
+                throw new Error(`Video channel '${channel}' not found`);
+            }
+            const captureModes = channelData.captureMode;
+            const captureMode = captureModes.find((x) => x.enabled === true);
+            if (captureMode === undefined) {
+                throw new Error(`No enabled capture mode found.`);
+            }
+            const maxFps = parseInt(captureMode.maxFPS, 10);
+            if (isNaN(maxFps)) {
+                throw new Error(`Max fps not specified for given capture mode.`);
+            }
+            return maxFps;
+        });
+    }
+    getTimezone() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = JSON.stringify({ apiVersion: '1.0', method: 'getDateTimeInfo' });
+            const res = yield this.vapixPost('/axis-cgi/time.cgi', data);
+            if (res.ok) {
+                return (_b = (_a = ((yield res.json()))) === null || _a === void 0 ? void 0 : _a.timeZone) !== null && _b !== void 0 ? _b : 'Europe/Prague';
+            }
+            else {
+                throw new Error(yield (0, common_1.responseStringify)(res));
+            }
+        });
+    }
+    getHeaders() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = JSON.stringify({ apiVersion: '1.0', method: 'list' });
+                const res = yield this.vapixPost('/axis-cgi/customhttpheader.cgi', data);
+                if (res.ok) {
+                    return (_a = (yield res.json()).data) !== null && _a !== void 0 ? _a : {};
+                }
+                else {
+                    return {};
+                }
+            }
+            catch (e) {
+                return {};
+            }
+        });
+    }
+    setHeaders(headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = JSON.stringify({ apiVersion: '1.0', method: 'set', params: headers });
+            return this.vapixPost('/axis-cgi/customhttpheader.cgi', data);
+        });
+    }
+    parseGetParametrs(response) {
+        const params = {};
+        const lines = response.split(/[\r\n]/);
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].substring(0, 7) === '# Error') {
+                continue;
+            }
+            if (lines[i].length) {
+                const p = lines[i].split(/=(.+)/);
+                if (p.length >= 2) {
+                    const paramName = p[0].replace('root.', '');
+                    params[paramName] = String(p[1]);
+                }
+                else if (p[0].substring(0, 7) !== '# Error') {
+                    params[p[0].slice(0, -1)] = '';
+                }
+            }
+        }
+        return params;
+    }
     getParameterGroup(groupNames) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield (yield this.vapixGet(`/axis-cgi/param.cgi?action=list&group=${encodeURIComponent(groupNames)}`)).text();
             const params = {};
             const lines = response.split(/[\r\n]/);
-            for (const line of lines) {
-                const delimiterPos = line.indexOf('=');
-                if (delimiterPos !== -1) {
-                    const key = line.substring(0, delimiterPos);
-                    const value = line.substring(delimiterPos + 1);
-                    params[key] = value;
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].length) {
+                    const p = lines[i].split('=');
+                    if (p.length >= 2) {
+                        params[p[0]] = p[1];
+                    }
                 }
             }
             return params;
@@ -59,26 +225,6 @@ class CameraVapix extends eventemitter2_1.EventEmitter2 {
         postData = postData.slice(0, postData.length - 1);
         return this.vapixPost('/axis-cgi/param.cgi', postData);
     }
-    getPTZPresetList(channel) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield (yield this.vapixGet(`/axis-cgi/com/ptz.cgi?query=presetposcam&camera=${encodeURIComponent(channel)}`)).text();
-            const positions = [];
-            const lines = response.split(/[\r\n]/);
-            for (const line of lines) {
-                if (line.indexOf('presetposno') !== -1) {
-                    const delimiterPos = line.indexOf('=');
-                    if (delimiterPos !== -1) {
-                        const value = line.substring(delimiterPos + 1);
-                        positions.push(value);
-                    }
-                }
-            }
-            return positions;
-        });
-    }
-    goToPreset(channel, presetName) {
-        return this.vapixPost('/axis-cgi/com/ptz.cgi', `camera=${encodeURIComponent(channel)}&gotoserverpresetname=${encodeURIComponent(presetName)}`);
-    }
     getGuardTourList() {
         return __awaiter(this, void 0, void 0, function* () {
             const gTourList = new Array();
@@ -122,6 +268,121 @@ class CameraVapix extends eventemitter2_1.EventEmitter2 {
         options[gourTourID + '.Running'] = enable ? 'yes' : 'no';
         return this.setParameter(options);
     }
+    parsePtz(parsed) {
+        const res = [];
+        parsed.forEach((value) => {
+            const valueData = value.split('=');
+            if (valueData.length < 2) {
+                return;
+            }
+            if (!valueData[0].startsWith('presetposno')) {
+                return;
+            }
+            const id = Number(valueData[0].replace('presetposno', ''));
+            if (Number.isNaN(id)) {
+                return;
+            }
+            const data = valueData[1].split(':');
+            const getValue = (valueName) => {
+                for (const d of data) {
+                    const p = d.split('=');
+                    if (p[0] === valueName) {
+                        return Number(p[1]);
+                    }
+                }
+                return 0;
+            };
+            res.push({
+                id,
+                name: data[0],
+                data: {
+                    pan: getValue('pan'),
+                    tilt: getValue('tilt'),
+                    zoom: getValue('zoom'),
+                },
+            });
+        });
+        return res;
+    }
+    parseCameraPtzFromReq(response) {
+        const json = JSON.parse(response);
+        const parsed = {};
+        Object.keys(json).forEach((key) => {
+            if (!key.startsWith('Camera ')) {
+                return;
+            }
+            const camera = Number(key.replace('Camera ', ''));
+            if (json[key].presets !== undefined) {
+                parsed[camera] = this.parsePtz(json[key].presets);
+            }
+        });
+        return parsed;
+    }
+    getPTZPresetList(channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (yield this.vapixGet(`/axis-cgi/com/ptz.cgi?query=presetposcam&camera=${encodeURIComponent(channel)}`)).text();
+            const positions = [];
+            const lines = response.split(/[\r\n]/);
+            for (const line of lines) {
+                if (line.indexOf('presetposno') !== -1) {
+                    const delimiterPos = line.indexOf('=');
+                    if (delimiterPos !== -1) {
+                        const value = line.substring(delimiterPos + 1);
+                        positions.push(value);
+                    }
+                }
+            }
+            return positions;
+        });
+    }
+    listPtzVideoSourceOverview() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.vapixGet(`/axis-cgi/com/ptz.cgi`, {
+                    query: 'presetposall',
+                    format: 'json',
+                });
+                const data = this.parseCameraPtzFromReq(yield response.text());
+                const res = {};
+                Object.keys(data).forEach((camera) => {
+                    res[Number(camera) - 1] = data[Number(camera)].map((_a) => {
+                        var { data } = _a, d = __rest(_a, ["data"]);
+                        return d;
+                    });
+                });
+                return res;
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    goToPreset(channel, presetName) {
+        return this.vapixPost('/axis-cgi/com/ptz.cgi', `camera=${encodeURIComponent(channel)}&gotoserverpresetname=${encodeURIComponent(presetName)}`);
+    }
+    getPtzPosition(camera) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.vapixGet(`/axis-cgi/com/ptz.cgi`, {
+                    query: 'position',
+                    camera: camera.toString(),
+                });
+                const data = this.parseGetParametrs(yield res.text());
+                return {
+                    pan: Number(data.pan),
+                    tilt: Number(data.tilt),
+                    zoom: Number(data.zoom),
+                };
+            }
+            catch (err) {
+                return {
+                    pan: 0,
+                    tilt: 0,
+                    zoom: 0,
+                };
+            }
+        });
+    }
     getInputState(port) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield (yield this.vapixPost('/axis-cgi/io/port.cgi', `checkactive=${encodeURIComponent(port)}`)).text();
@@ -129,11 +390,13 @@ class CameraVapix extends eventemitter2_1.EventEmitter2 {
         });
     }
     setOutputState(port, active) {
-        return this.vapixPost('/axis-cgi/io/port.cgi', `action=${encodeURIComponent(port)}:${active ? '/' : '\\'}`);
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.vapixPost('/axis-cgi/io/port.cgi', `action=${encodeURIComponent(port)}:${active ? '/' : '\\'}`);
+        });
     }
     getApplicationList() {
         return __awaiter(this, void 0, void 0, function* () {
-            const xml = yield this.vapixGet('/axis-cgi/applications/list.cgi');
+            const xml = yield (yield this.vapixGet('/axis-cgi/applications/list.cgi')).text();
             const result = (yield (0, xml2js_1.parseStringPromise)(xml));
             const apps = [];
             for (let i = 0; i < result.reply.application.length; i++) {
@@ -142,26 +405,55 @@ class CameraVapix extends eventemitter2_1.EventEmitter2 {
             return apps;
         });
     }
-    getCameraImage(camera, compression, resolution, outputStream) {
+    startApplication(applicationID) {
         return __awaiter(this, void 0, void 0, function* () {
-            const path = `/axis-cgi/jpg/image.cgi?resolution=${resolution}&compression=${compression}&camera=${camera}`;
-            const res = yield this.vapixGet(path);
-            if (res.body) {
-                void res.body.pipeTo(outputStream);
+            const res = yield this.vapixGet('/axis-cgi/applications/control.cgi', {
+                package: applicationID.toLowerCase(),
+                action: 'start',
+            });
+            const text = (yield res.text()).trim().toLowerCase();
+            if (res.ok && text === 'ok') {
+                return;
+            }
+            else if (text.startsWith('error:') && text.substring(7) === '6') {
+                return;
+            }
+            else {
+                throw new Error(yield (0, common_1.responseStringify)(res));
             }
-            return outputStream;
         });
     }
-    getEventDeclarations() {
+    restartApplication(applicationID) {
         return __awaiter(this, void 0, void 0, function* () {
-            const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
-                '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
-                'xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
-                '<GetEventInstances xmlns="http://www.axis.com/vapix/ws/event1"/>' +
-                '</s:Body>' +
-                '</s:Envelope>';
-            const declarations = yield this.vapixPost('/vapix/services', data, 'application/soap+xml');
-            return prettifyXml(declarations);
+            const res = yield this.vapixGet('/axis-cgi/applications/control.cgi', {
+                package: applicationID.toLowerCase(),
+                action: 'restart',
+            });
+            const text = (yield res.text()).trim().toLowerCase();
+            if (res.ok && text === 'ok') {
+                return;
+            }
+            else {
+                throw new Error(yield (0, common_1.responseStringify)(res));
+            }
+        });
+    }
+    stopApplication(applicationID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.vapixGet('/axis-cgi/applications/control.cgi', {
+                package: applicationID.toLowerCase(),
+                action: 'stop',
+            });
+            const text = (yield res.text()).trim().toLowerCase();
+            if (res.ok && text === 'ok') {
+                return;
+            }
+            else if (text.startsWith('error:') && text.substring(7) === '6') {
+                return;
+            }
+            else {
+                throw new Error(yield (0, common_1.responseStringify)(res));
+            }
         });
     }
 }

package/VapixEvents.d.ts

@@ -1,6 +1,31 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
 import { WsOptions } from './internal/common';
 export type VapixEventsOptions = WsOptions;
+type TEventMessage = {
+    apiVersion: string;
+    method: string;
+    params: {
+        notification: {
+            timestamp: number;
+            topic: string;
+            message: {
+                source: Record<string, string>;
+                data: Record<string, string>;
+                key: Record<string, string>;
+            };
+        };
+    };
+};
+export interface VapixEvents {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: string, listener: (data: TEventMessage) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: string, msg: TEventMessage): boolean;
+}
 export declare class VapixEvents extends EventEmitter {
     private tls;
     private tlsInsecure;
@@ -15,3 +40,4 @@ export declare class VapixEvents extends EventEmitter {
     private createWsClient;
     private isReservedEventName;
 }
+export {};

package/internal/HttpRequestSender.js

@@ -30,16 +30,15 @@ class HttpRequestSender {
         return this.sendRequestWithAuth(options, postData);
     }
     sendRequestWithAuth(options, postData, wwwAuthenticateHeader) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            (_a = options.timeout) !== null && _a !== void 0 ? _a : (options.timeout = 10000);
             const url = HttpRequestSender.getURL(options);
             const controller = new AbortController();
-            if (options.timeout !== undefined) {
-                setTimeout(() => controller.abort(new Error('Request timeout')), options.timeout);
-            }
+            setTimeout(() => controller.abort(new Error('Request timeout')), options.timeout);
             const authorization = this.getAuthorization(options, wwwAuthenticateHeader);
             if (authorization !== undefined) {
-                (_a = options.headers) !== null && _a !== void 0 ? _a : (options.headers = {});
+                (_b = options.headers) !== null && _b !== void 0 ? _b : (options.headers = {});
                 options.headers['Authorization'] = authorization;
             }
             let res;

package/internal/WsClient.d.ts

@@ -8,6 +8,16 @@ export type WsClientOptions = WsOptions & {
     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 {
     private user;
     private pass;

package/internal/common.d.ts

@@ -20,4 +20,5 @@ export interface IClient {
 }
 export declare function isClient(arg?: Options | IClient): arg is IClient;
 export declare function isBrowserEnvironment(): boolean;
+export declare function responseStringify(res: Response): Promise<string>;
 export {};

package/internal/common.js

@@ -1,6 +1,15 @@
 "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.isBrowserEnvironment = exports.isClient = void 0;
+exports.responseStringify = exports.isBrowserEnvironment = exports.isClient = void 0;
 function isClient(arg = {}) {
     return 'get' in arg && 'post' in arg;
 }
@@ -9,3 +18,12 @@ function isBrowserEnvironment() {
     return typeof process === 'undefined' || process.versions === null || process.versions.node === null;
 }
 exports.isBrowserEnvironment = isBrowserEnvironment;
+function responseStringify(res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return JSON.stringify({
+            status: res.status,
+            body: yield res.text(),
+        });
+    });
+}
+exports.responseStringify = responseStringify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camstreamerlib",
-  "version": "3.2.2",
+  "version": "3.2.4",
   "description": "Helper library for CamStreamer ACAP applications.",
   "prettier": "@camstreamer/prettier-config",
   "dependencies": {