camstreamerlib 4.0.0-beta.99 → 4.0.1

package/esm/VapixAPI.js

@@ -1,19 +1,15 @@
 import { arrayToUrl, isNullish, paramToUrl } from './internal/utils';
-import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, guardTourSchema, ptzOverviewSchema, cameraPTZItemDataSchema, applicationListSchema, sdCardInfoSchema, } from './types/VapixAPI';
+import { sdCardWatchedStatuses, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, guardTourSchema, ptzOverviewSchema, cameraPTZItemDataSchema, applicationListSchema, sdCardInfoSchema, ALL_APP_IDS, } from './types/VapixAPI';
 import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, ErrorWithResponse, SDCardActionError, SDCardJobError, SettingParameterError, TimezoneFetchError, TimezoneNotSetupError, } from './errors/errors';
-import { ProxyClient } from './internal/ProxyClient';
 import { z } from 'zod';
 import { XMLParser } from 'fast-xml-parser';
-export class VapixAPI {
-    client;
+import { BasicAPI } from './internal/BasicAPI';
+export class VapixAPI extends BasicAPI {
     CustomFormData;
     constructor(client, CustomFormData = FormData) {
-        this.client = client;
+        super(client);
         this.CustomFormData = CustomFormData;
     }
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
-    }
     async postUrlEncoded(path, parameters, headers, options) {
         const data = paramToUrl(parameters);
         const head = { ...headers, 'Content-Type': 'application/x-www-form-urlencoded' };
@@ -24,11 +20,15 @@ export class VapixAPI {
         }
         return res;
     }
-    async postJson(path, jsonData, headers, options) {
-        const data = JSON.stringify(jsonData);
-        const head = { ...headers, 'Content-Type': 'application/json' };
+    async postJson(path, data, headers, options) {
         const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ path, data, headers: head, timeout: options?.timeout });
+        const jsonData = JSON.stringify(data);
+        const res = await agent.post({
+            path,
+            data: jsonData,
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            timeout: options?.timeout,
+        });
         if (!res.ok) {
             throw new ErrorWithResponse(res);
         }
@@ -36,11 +36,18 @@ export class VapixAPI {
     }
     async getCameraImage(parameters, options) {
         const agent = this.getClient(options?.proxyParams);
-        return (await agent.get({
+        const res = await agent.get({
             path: '/axis-cgi/jpg/image.cgi',
             parameters,
             timeout: options?.timeout,
-        }));
+        });
+        if (!res.ok) {
+            throw new ErrorWithResponse(res);
+        }
+        if (res.headers.get('content-type') !== 'image/jpeg') {
+            throw new Error(`Unexpected content-type: ${res.headers.get('content-type')}`);
+        }
+        return res;
     }
     async getEventDeclarations(options) {
         const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
@@ -63,7 +70,7 @@ export class VapixAPI {
     async getSupportedAudioSampleRate(options) {
         const path = '/axis-cgi/audio/streamingcapabilities.cgi';
         const jsonData = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson(path, jsonData, undefined, options);
+        const res = await this._postJsonEncoded(path, jsonData, undefined, options);
         const encoders = audioSampleRatesResponseSchema.parse(await res.json()).data.encoders;
         const data = encoders.aac ?? encoders.AAC ?? [];
         return data.map((item) => {
@@ -86,83 +93,25 @@ export class VapixAPI {
                     ],
                 },
             };
-            await this.postJson('/axis-cgi/opticscontrol.cgi', data, undefined, options);
+            await this._postJsonEncoded('/axis-cgi/opticscontrol.cgi', data, undefined, options);
         }
         catch (err) {
-            await this.postUrlEncoded('/axis-cgi/opticssetup.cgi', {
+            await this._postUrlEncoded('/axis-cgi/opticssetup.cgi', {
                 autofocus: 'perform',
                 source: '1',
-            }, undefined, options);
-        }
-    }
-    async checkSDCard(options) {
-        const res = await this.postUrlEncoded('/axis-cgi/disks/list.cgi', {
-            diskid: 'SD_DISK',
-        }, undefined, options);
-        const xmlText = await res.text();
-        const parser = new XMLParser({
-            ignoreAttributes: false,
-            attributeNamePrefix: '',
-            allowBooleanAttributes: true,
-        });
-        const result = parser.parse(xmlText);
-        const data = result.root.disks.disk;
-        return sdCardInfoSchema.parse({
-            totalSize: parseInt(data.totalsize),
-            freeSize: parseInt(data.freesize),
-            status: sdCardWatchedStatuses.includes(data.status) ? data.status : 'disconnected',
-        });
-    }
-    mountSDCard(options) {
-        return this._doSDCardMountAction('MOUNT', options);
-    }
-    unmountSDCard(options) {
-        return this._doSDCardMountAction('UNMOUNT', options);
-    }
-    async _doSDCardMountAction(action, options) {
-        const res = await this.postUrlEncoded('/axis-cgi/disks/mount.cgi', {
-            action: action,
-            diskid: 'SD_DISK',
-        }, undefined, options);
-        const textXml = await res.text();
-        const parser = new XMLParser({
-            ignoreAttributes: false,
-            attributeNamePrefix: '',
-            allowBooleanAttributes: true,
-        });
-        const result = parser.parse(textXml);
-        const job = result.root.job;
-        if (job.result !== 'OK') {
-            throw new SDCardActionError(action, job.description);
+            }, options);
         }
-        return Number(job.jobid);
-    }
-    async fetchSDCardJobProgress(jobId, options) {
-        const res = await this.postUrlEncoded('/disks/job.cgi', {
-            jobid: String(jobId),
-            diskid: 'SD_DISK',
-        }, undefined, options);
-        const textXml = await res.text();
-        const parser = new XMLParser({
-            ignoreAttributes: false,
-            attributeNamePrefix: '',
-            allowBooleanAttributes: true,
-        });
-        const job = parser.parse(textXml).root.job;
-        if (job.result !== 'OK') {
-            throw new SDCardJobError(job.description);
-        }
-        return Number(job.progress);
     }
     downloadCameraReport(options) {
-        return this.postUrlEncoded('/axis-cgi/serverreport.cgi', { mode: 'text' }, undefined, options);
+        return this._getText('/axis-cgi/serverreport.cgi', { mode: 'text' }, options);
     }
-    getSystemLog(options) {
-        return this.postUrlEncoded('/axis-cgi/admin/systemlog.cgi', undefined, undefined, options);
+    async getSystemLog(options) {
+        const res = await this._postUrlEncoded('/axis-cgi/admin/systemlog.cgi', {}, options);
+        return res.text();
     }
     async getMaxFps(channel, options) {
         const data = { apiVersion: '1.0', method: 'getCaptureModes' };
-        const res = await this.postJson('/axis-cgi/capturemode.cgi', data, undefined, options);
+        const res = await this._postJsonEncoded('/axis-cgi/capturemode.cgi', data, undefined, options);
         const response = maxFpsResponseSchema.parse(await res.json());
         const channels = response.data;
         if (channels === undefined) {
@@ -208,12 +157,12 @@ export class VapixAPI {
     }
     async getDateTimeInfo(options) {
         const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
-        const res = await this.postJson('/axis-cgi/time.cgi', data, undefined, options);
+        const res = await this._postJsonEncoded('/axis-cgi/time.cgi', data, undefined, options);
         return dateTimeinfoSchema.parse(await res.json());
     }
     async getDevicesSettings(options) {
         const data = { apiVersion: '1.0', method: 'getDevicesSettings' };
-        const res = await this.postJson('/axis-cgi/audiodevicecontrol.cgi', data, undefined, options);
+        const res = await this._postJsonEncoded('/axis-cgi/audiodevicecontrol.cgi', data, undefined, options);
         const result = audioDeviceRequestSchema.parse(await res.json());
         return result.data.devices.map((device) => ({
             ...device,
@@ -222,7 +171,7 @@ export class VapixAPI {
         }));
     }
     async fetchRemoteDeviceInfo(payload, options) {
-        const res = await this.postJson('/axis-cgi/basicdeviceinfo.cgi', payload, undefined, options);
+        const res = await this._postJsonEncoded('/axis-cgi/basicdeviceinfo.cgi', payload, undefined, options);
         const json = await res.json();
         if (isNullish(json.data)) {
             throw new NoDeviceInfoError();
@@ -231,25 +180,84 @@ export class VapixAPI {
     }
     async getHeaders(options) {
         const data = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson('/axis-cgi/customhttpheader.cgi', data, undefined, options);
+        const res = await this._postJsonEncoded('/axis-cgi/customhttpheader.cgi', data, undefined, options);
         return z.object({ data: z.record(z.string()) }).parse(await res.json()).data;
     }
     async setHeaders(headers, options) {
         const data = { apiVersion: '1.0', method: 'set', params: headers };
-        return this.postJson('/axis-cgi/customhttpheader.cgi', data, undefined, options);
+        await this._postJsonEncoded('/axis-cgi/customhttpheader.cgi', data, undefined, options);
+    }
+    async checkSDCard(options) {
+        const res = await this._postUrlEncoded('/axis-cgi/disks/list.cgi', {
+            diskid: 'SD_DISK',
+        }, options);
+        const xmlText = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const result = parser.parse(xmlText);
+        const data = result.root.disks.disk;
+        return sdCardInfoSchema.parse({
+            totalSize: parseInt(data.totalsize),
+            freeSize: parseInt(data.freesize),
+            status: sdCardWatchedStatuses.includes(data.status) ? data.status : 'disconnected',
+        });
+    }
+    mountSDCard(options) {
+        return this._doSDCardMountAction('MOUNT', options);
+    }
+    unmountSDCard(options) {
+        return this._doSDCardMountAction('UNMOUNT', options);
+    }
+    async _doSDCardMountAction(action, options) {
+        const res = await this._postUrlEncoded('/axis-cgi/disks/mount.cgi', {
+            action: action,
+            diskid: 'SD_DISK',
+        }, options);
+        const textXml = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const result = parser.parse(textXml);
+        const job = result.root.job;
+        if (job.result !== 'OK') {
+            throw new SDCardActionError(action, job.description);
+        }
+        return Number(job.jobid);
+    }
+    async fetchSDCardJobProgress(jobId, options) {
+        const res = await this._postUrlEncoded('/disks/job.cgi', {
+            jobid: String(jobId),
+            diskid: 'SD_DISK',
+        }, options);
+        const textXml = await res.text();
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const job = parser.parse(textXml).root.job;
+        if (job.result !== 'OK') {
+            throw new SDCardJobError(job.description);
+        }
+        return Number(job.progress);
     }
     async getParameter(paramNames, options) {
-        const response = await this.postUrlEncoded('/axis-cgi/param.cgi', {
+        const response = await this._postUrlEncoded('/axis-cgi/param.cgi', {
             action: 'list',
             group: arrayToUrl(paramNames),
-        }, undefined, options);
+        }, options);
         return VapixAPI.parseParameters(await response.text());
     }
     async setParameter(params, options) {
-        const res = await this.postUrlEncoded('/axis-cgi/param.cgi', {
+        const res = await this._postUrlEncoded('/axis-cgi/param.cgi', {
             ...params,
             action: 'update',
-        }, undefined, options);
+        }, options);
         const responseText = await res.text();
         if (responseText.startsWith('# Error')) {
             throw new SettingParameterError(responseText);
@@ -297,10 +305,10 @@ export class VapixAPI {
         return this.setParameter(params, options);
     }
     async getPTZPresetList(channel, options) {
-        const res = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
+        const res = await this._postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposcam',
             camera: channel,
-        }, undefined, options);
+        }, options);
         const text = await res.text();
         const lines = text.split(/[\r\n]/);
         const positions = [];
@@ -317,11 +325,11 @@ export class VapixAPI {
     }
     async listPTZ(camera, options) {
         const url = `/axis-cgi/com/ptz.cgi`;
-        const response = await this.postUrlEncoded(url, {
+        const response = await this._postUrlEncoded(url, {
             camera,
             query: 'presetposcamdata',
             format: 'json',
-        }, undefined, options);
+        }, options);
         const text = await response.text();
         if (text === '') {
             throw new PtzNotSupportedError();
@@ -329,10 +337,10 @@ export class VapixAPI {
         return VapixAPI.parseCameraPtzResponse(text)[camera] ?? [];
     }
     async listPtzVideoSourceOverview(options) {
-        const response = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
+        const response = await this._postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposall',
             format: 'json',
-        }, undefined, options);
+        }, options);
         const text = await response.text();
         if (text === '') {
             throw new PtzNotSupportedError();
@@ -349,17 +357,17 @@ export class VapixAPI {
         });
         return ptzOverviewSchema.parse(res);
     }
-    goToPreset(channel, presetName, options) {
-        return this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
+    async goToPreset(channel, presetName, options) {
+        await this._postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             camera: channel.toString(),
             gotoserverpresetname: presetName,
-        }, undefined, options);
+        }, options);
     }
     async getPtzPosition(camera, options) {
-        const res = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
+        const res = await this._postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'position',
             camera: camera.toString(),
-        }, undefined, options);
+        }, options);
         const params = VapixAPI.parseParameters(await res.text());
         return cameraPTZItemDataSchema.parse({
             pan: Number(params.pan),
@@ -368,16 +376,16 @@ export class VapixAPI {
         });
     }
     async getPorts(options) {
-        const res = await this.postJson('/axis-cgi/io/portmanagement.cgi', {
+        const res = await this._postJsonEncoded('/axis-cgi/io/portmanagement.cgi', {
             apiVersion: '1.0',
             context: '',
             method: 'getPorts',
         }, undefined, options);
         const portResponseParsed = getPortsResponseSchema.parse(await res.json());
-        return portResponseParsed.data.items;
+        return portResponseParsed.data.items ?? [];
     }
     async setPorts(ports, options) {
-        await this.postJson('/axis-cgi/io/portmanagement.cgi', {
+        await this._postJsonEncoded('/axis-cgi/io/portmanagement.cgi', {
             apiVersion: '1.0',
             context: '',
             method: 'setPorts',
@@ -385,13 +393,103 @@ export class VapixAPI {
         }, undefined, options);
     }
     async setPortStateSequence(port, sequence, options) {
-        await this.postJson('/axis-cgi/io/portmanagement.cgi', {
+        await this._postJsonEncoded('/axis-cgi/io/portmanagement.cgi', {
             apiVersion: '1.0',
             context: '',
             method: 'setStateSequence',
             params: { port, sequence },
         }, undefined, options);
     }
+    async addCameraUser(username, pass, sgrp, comment, options) {
+        const res = await this._postUrlEncoded('/axis-cgi/pwdgrp.cgi', {
+            action: 'add',
+            user: username,
+            pwd: pass,
+            grp: 'users',
+            sgrp,
+            comment,
+        }, options);
+        await VapixAPI.checkTextResponseForError(res);
+    }
+    async getCameraUsers(options) {
+        const res = await this._postUrlEncoded('/axis-cgi/pwdgrp.cgi', {
+            action: 'get',
+        }, options);
+        const responseText = await VapixAPI.checkTextResponseForError(res);
+        const viewersString = responseText.match(/^viewer="([a-z0-9,]*)"/im)?.[1] ?? '';
+        return viewersString.split(',');
+    }
+    async editCameraUser(username, pass, options) {
+        const res = await this._postUrlEncoded('/axis-cgi/pwdgrp.cgi', {
+            action: 'update',
+            user: username,
+            pwd: pass,
+        }, options);
+        await VapixAPI.checkTextResponseForError(res);
+    }
+    async getRecordingRuleList(options) {
+        const res = await this._getText('/axis-cgi/record/continuous/listconfiguration.cgi', undefined, options);
+        const resultNode = VapixAPI.parseXmlResponse(res, 'continuousrecordingconfigurations');
+        const configurationNodes = resultNode.getElementsByTagName('continuousrecordingconfiguration');
+        const configs = [];
+        for (const node of configurationNodes) {
+            if (isNullish(node)) {
+                continue;
+            }
+            configs.push({
+                profile: node.getAttribute('profile') ?? '',
+                diskid: node.getAttribute('diskid') ?? '',
+                options: VapixAPI.parseQueryString(node.getAttribute('options')),
+                eventid: node.getAttribute('eventid') ?? '',
+            });
+        }
+        return configs;
+    }
+    async addRecordingRule(params, options) {
+        const res = await this._getText('/axis-cgi/record/continuous/addconfiguration.cgi', params, options);
+        const resultNode = VapixAPI.parseXmlResponse(res, 'configure');
+        const result = resultNode.getAttribute('result');
+        if (result !== 'OK') {
+            throw new Error(resultNode.getAttribute('errormsg') ?? result ?? 'Unknown error');
+        }
+        return resultNode.getAttribute('profile');
+    }
+    async removeRecordingRule(profileId, options) {
+        const res = await this._getText('/axis-cgi/record/continuous/removeconfiguration.cgi', {
+            profile: profileId,
+        }, options);
+        const resultNode = VapixAPI.parseXmlResponse(res, 'remove');
+        const result = resultNode.getAttribute('result');
+        if (result !== 'OK') {
+            throw new Error(resultNode.getAttribute('errormsg') ?? result ?? 'Unknown error');
+        }
+    }
+    async getDiskInfo(diskId = 'all', options) {
+        const res = await this._getText('/axis-cgi/disks/list.cgi', {
+            diskid: diskId,
+        }, options);
+        const resultNode = VapixAPI.parseXmlResponse(res, 'disks');
+        const disks = resultNode.getElementsByTagName('disk');
+        if (isNullish(disks) || disks.length === 0) {
+            return false;
+        }
+        const requiredReadyProps = {
+            status: 'OK',
+            locked: 'no',
+            readonly: 'no',
+        };
+        for (const disk of disks) {
+            let isReady = true;
+            for (const name in requiredReadyProps) {
+                const value = disk.getAttribute(name);
+                isReady = isReady && requiredReadyProps[name] === value;
+            }
+            if (isReady) {
+                return true;
+            }
+        }
+        return false;
+    }
     async getApplicationList(options) {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({ path: '/axis-cgi/applications/list.cgi', timeout: options?.timeout });
@@ -409,7 +507,7 @@ export class VapixAPI {
         const appList = apps.map((app) => {
             return {
                 ...app,
-                appId: APP_IDS.find((id) => id.toLowerCase() === app.Name.toLowerCase()) ?? null,
+                appId: ALL_APP_IDS.find((id) => id.toLowerCase() === app.Name.toLowerCase()) ?? null,
             };
         });
         return applicationListSchema.parse(appList);
@@ -469,7 +567,7 @@ export class VapixAPI {
             headers: {
                 contentType: 'application/octet-stream',
             },
-            timeout: options?.timeout ?? 120000,
+            timeout: options?.timeout ?? 300000,
         });
         if (!res.ok) {
             throw new ErrorWithResponse(res);
@@ -479,6 +577,21 @@ export class VapixAPI {
             throw new ApplicationAPIError('INSTALL', text);
         }
     }
+    static parseQueryString = (queryString) => {
+        const entries = queryString
+            ?.split('&')
+            .filter((x) => x !== '')
+            .map((x) => x.split('=', 2));
+        return !isNullish(entries) ? Object.fromEntries(entries) : {};
+    };
+    static checkTextResponseForError = async (response) => {
+        const responseText = await response.text();
+        const isError = responseText.match(/Error:([^<]*)/);
+        if (!isNullish(isError)) {
+            throw new ErrorWithResponse(response);
+        }
+        return responseText;
+    };
     static parseParameters = (response) => {
         const params = {};
         const lines = response.split(/[\r\n]/);
@@ -545,4 +658,12 @@ export class VapixAPI {
         });
         return res;
     };
+    static parseXmlResponse = (xml, nodeName) => {
+        const doc = new DOMParser().parseFromString(xml, 'text/xml');
+        const node = doc.getElementsByTagName(nodeName);
+        if (node.length !== 1 || isNullish(node[0])) {
+            throw new Error('Invalid XML from camera');
+        }
+        return node[0];
+    };
 }

package/esm/errors/errors.js

@@ -176,11 +176,15 @@ export class BadRequestError extends ErrorWithResponse {
 }
 export class MigrationError extends Error {
     valid;
+    old;
     invalid;
-    constructor(valid, invalid) {
+    unknown;
+    constructor(valid, old, invalid = [], unknown = []) {
         super('Migration to newer version is needed: some stream entries failed to parse.');
         this.name = 'MigrationError';
         this.valid = valid;
+        this.old = old;
         this.invalid = invalid;
+        this.unknown = unknown;
     }
 }

package/esm/index.js

@@ -1,6 +1,7 @@
 export * from './errors/errors';
 export * from './internal/types';
 export * from './internal/constants';
+export * from './internal/convertors';
 export * from './internal/utils';
 export * from './internal/versionCompare';
 export * from './internal/ProxyClient';

package/esm/internal/BasicAPI.js

@@ -0,0 +1,89 @@
+import { ErrorWithResponse, ParsingBlobError } from '../errors/errors';
+import { ProxyClient } from './ProxyClient';
+import { paramToUrl } from './utils';
+export class BasicAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async _getJson(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new ErrorWithResponse(res);
+        }
+    }
+    async _getText(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
+        if (res.ok) {
+            return await res.text();
+        }
+        else {
+            throw new ErrorWithResponse(res);
+        }
+    }
+    async _getBlob(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new ErrorWithResponse(res);
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new ParsingBlobError(err);
+        }
+    }
+    async _post(path, data, parameters, options, headers) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new ErrorWithResponse(res);
+        }
+    }
+    async _postJsonEncoded(path, data, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const jsonData = JSON.stringify(data);
+        const res = await agent.post({
+            path,
+            data: jsonData,
+            parameters,
+            headers: { 'Content-Type': 'application/json' },
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            throw new ErrorWithResponse(res);
+        }
+        return res;
+    }
+    async _postUrlEncoded(path, data, options) {
+        const encodedData = paramToUrl(data);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path,
+            data: encodedData,
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            timeout: options?.timeout,
+        });
+        if (!res.ok) {
+            throw new ErrorWithResponse(res);
+        }
+        return res;
+    }
+}

package/esm/internal/WsEvents.js

@@ -34,6 +34,11 @@ export class WsEvents {
             }
         }
     }
+    removeAllListenersForId(id) {
+        for (const type in this.listeners) {
+            this.removeListener(type, id);
+        }
+    }
     onMessage(incomeData) {
         if (this.isDestroyed) {
             return;

package/esm/internal/constants.js

@@ -1 +1,2 @@
 export const FIRMWARE_WITH_BITRATE_MODES_SUPPORT = '11.11.73';
+export const FIRMWARE_WITH_OVERLAYS_SUPPORT = '10.7.0';