camstreamerlib 4.0.0-beta.15 → 4.0.0-beta.151

package/esm/VapixAPI.js

@@ -1,54 +1,69 @@
-import * as prettifyXml from 'prettify-xml';
-import { arrayToUrl, isNullish, paramToUrl, responseStringify } from './internal/utils';
-import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, } from './types/VapixAPI';
-import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, SDCardActionError, SDCardJobError, } from './errors/errors';
-import { ProxyClient } from './internal/ProxyClient';
+import { arrayToUrl, isNullish, paramToUrl } from './internal/utils';
+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 { z } from 'zod';
 import { XMLParser } from 'fast-xml-parser';
-export class VapixAPI {
-    client;
-    constructor(client, getProxyUrl) {
-        this.client = new ProxyClient(client, getProxyUrl);
-    }
-    async getUrlEncoded(proxy, path, parameters, headers = {}) {
+import { BasicAPI } from './internal/BasicAPI';
+export class VapixAPI extends BasicAPI {
+    CustomFormData;
+    constructor(client, CustomFormData = FormData) {
+        super(client);
+        this.CustomFormData = CustomFormData;
+    }
+    async postUrlEncoded(path, parameters, headers, options) {
         const data = paramToUrl(parameters);
         const head = { ...headers, 'Content-Type': 'application/x-www-form-urlencoded' };
-        const res = await this.client.post(proxy, path, data, {}, head);
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, headers: head, timeout: options?.timeout });
         if (!res.ok) {
-            throw new Error(await responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
         return res;
     }
-    async postJson(proxy, path, jsonData, headers = {}) {
-        const data = JSON.stringify(jsonData);
-        const head = { ...headers, 'Content-Type': 'application/json' };
-        const res = await this.client.post(proxy, path, data, {}, head);
+    async postJson(path, data, headers, options) {
+        const agent = this.getClient(options?.proxyParams);
+        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 Error(await responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
         return res;
     }
-    async getCameraImage(params, proxy = null) {
-        return await this.client.get(proxy, '/axis-cgi/jpg/image.cgi', params);
+    async getCameraImage(parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        return (await agent.get({
+            path: '/axis-cgi/jpg/image.cgi',
+            parameters,
+            timeout: options?.timeout,
+        }));
     }
-    async getEventDeclarations(proxy = null) {
+    async getEventDeclarations(options) {
         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 res = await this.client.post(proxy, '/vapix/services', data, { 'Content-Type': 'application/soap+xml' });
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path: '/vapix/services',
+            data,
+            headers: { 'Content-Type': 'application/soap+xml' },
+        });
         if (!res.ok) {
-            throw new Error(await responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
-        const declarations = await res.text();
-        return prettifyXml(declarations);
+        return await res.text();
     }
-    async getSupportedAudioSampleRate(proxy = null) {
-        const url = '/axis-cgi/audio/streamingcapabilities.cgi';
+    async getSupportedAudioSampleRate(options) {
+        const path = '/axis-cgi/audio/streamingcapabilities.cgi';
         const jsonData = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson(proxy, url, jsonData);
+        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) => {
@@ -58,7 +73,7 @@ export class VapixAPI {
             };
         });
     }
-    async performAutofocus(proxy = null) {
+    async performAutofocus(options) {
         try {
             const data = {
                 apiVersion: '1',
@@ -71,19 +86,19 @@ export class VapixAPI {
                     ],
                 },
             };
-            await this.postJson(proxy, '/axis-cgi/opticscontrol.cgi', data);
+            await this._postJsonEncoded('/axis-cgi/opticscontrol.cgi', data, undefined, options);
         }
         catch (err) {
-            await this.getUrlEncoded(proxy, '/axis-cgi/opticssetup.cgi', {
+            await this._postUrlEncoded('/axis-cgi/opticssetup.cgi', {
                 autofocus: 'perform',
                 source: '1',
-            });
+            }, options);
         }
     }
-    async checkSDCard(proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/list.cgi', {
+    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,
@@ -92,23 +107,23 @@ export class VapixAPI {
         });
         const result = parser.parse(xmlText);
         const data = result.root.disks.disk;
-        return {
+        return sdCardInfoSchema.parse({
             totalSize: parseInt(data.totalsize),
             freeSize: parseInt(data.freesize),
             status: sdCardWatchedStatuses.includes(data.status) ? data.status : 'disconnected',
-        };
+        });
     }
-    mountSDCard(proxy = null) {
-        return this._doSDCardMountAction('MOUNT', proxy);
+    mountSDCard(options) {
+        return this._doSDCardMountAction('MOUNT', options);
     }
-    unmountSDCard(proxy = null) {
-        return this._doSDCardMountAction('UNMOUNT', proxy);
+    unmountSDCard(options) {
+        return this._doSDCardMountAction('UNMOUNT', options);
     }
-    async _doSDCardMountAction(action, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/mount.cgi', {
+    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,
@@ -118,15 +133,15 @@ export class VapixAPI {
         const result = parser.parse(textXml);
         const job = result.root.job;
         if (job.result !== 'OK') {
-            throw new SDCardActionError(action, await responseStringify(res));
+            throw new SDCardActionError(action, job.description);
         }
         return Number(job.jobid);
     }
-    async fetchSDCardJobProgress(jobId, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/disks/job.cgi', {
+    async fetchSDCardJobProgress(jobId, options) {
+        const res = await this._postUrlEncoded('/axis-cgi/disks/job.cgi', {
             jobid: String(jobId),
             diskid: 'SD_DISK',
-        });
+        }, options);
         const textXml = await res.text();
         const parser = new XMLParser({
             ignoreAttributes: false,
@@ -135,19 +150,19 @@ export class VapixAPI {
         });
         const job = parser.parse(textXml).root.job;
         if (job.result !== 'OK') {
-            throw new SDCardJobError();
+            throw new SDCardJobError(job.description);
         }
         return Number(job.progress);
     }
-    downloadCameraReport(proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/serverreport.cgi', { mode: 'text' });
+    downloadCameraReport(options) {
+        return this._getText('/axis-cgi/serverreport.cgi', { mode: 'text' }, options);
     }
-    getSystemLog(proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/admin/systemlog.cgi');
+    getSystemLog(options) {
+        return this._postUrlEncoded('/axis-cgi/admin/systemlog.cgi', {}, options);
     }
-    async getMaxFps(channel, proxy = null) {
+    async getMaxFps(channel, options) {
         const data = { apiVersion: '1.0', method: 'getCaptureModes' };
-        const res = await this.postJson(proxy, '/axis-cgi/capturemode.cgi', data);
+        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) {
@@ -165,21 +180,40 @@ export class VapixAPI {
         if (isNullish(captureMode.maxFPS)) {
             throw new MaxFPSError('FPS_NOT_SPECIFIED');
         }
-        return captureMode.maxFPS;
+        return z.number().parse(captureMode.maxFPS);
     }
-    async getTimezone(proxy = null) {
-        const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
-        const res = await this.postJson(proxy, '/axis-cgi/time.cgi', data);
-        return (await res.json())?.timeZone ?? 'Europe/Prague';
+    async getTimezone(options) {
+        try {
+            const agent = this.getClient(options?.proxyParams);
+            const resV2 = await agent.get({ path: '/config/rest/time/v2/timeZone', timeout: options?.timeout });
+            if (!resV2.ok) {
+                throw new ErrorWithResponse(resV2);
+            }
+            const json = await resV2.json();
+            const data = timeZoneSchema.parse(json);
+            if (data.status === 'error') {
+                throw new TimezoneFetchError(data.error.message);
+            }
+            return data.data.activeTimeZone;
+        }
+        catch (error) {
+            console.warn('Failed to fetch time zone data from time API v2:', error instanceof Error ? error.message : JSON.stringify(error));
+            console.warn('Falling back to deprecated time API v1');
+        }
+        const data = await this.getDateTimeInfo(options);
+        if (data.data.timeZone === undefined) {
+            throw new TimezoneNotSetupError();
+        }
+        return z.string().parse(data.data.timeZone);
     }
-    async getDateTimeInfo(proxy = null) {
+    async getDateTimeInfo(options) {
         const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
-        const res = await this.postJson(proxy, '/axis-cgi/time.cgi', data);
+        const res = await this._postJsonEncoded('/axis-cgi/time.cgi', data, undefined, options);
         return dateTimeinfoSchema.parse(await res.json());
     }
-    async getDevicesSettings(proxy = null) {
+    async getDevicesSettings(options) {
         const data = { apiVersion: '1.0', method: 'getDevicesSettings' };
-        const res = await this.postJson(proxy, '/axis-cgi/audiodevicecontrol.cgi', data);
+        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,
@@ -187,46 +221,45 @@ export class VapixAPI {
             outputs: (device.outputs || []).sort((a, b) => a.id.localeCompare(b.id)),
         }));
     }
-    async fetchRemoteDeviceInfo(payload, proxy = null) {
-        const res = await this.postJson(proxy, '/axis-cgi/basicdeviceinfo.cgi', payload);
+    async fetchRemoteDeviceInfo(payload, 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();
         }
         return json.data;
     }
-    async getHeaders(proxy = null) {
+    async getHeaders(options) {
         const data = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+        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, proxy = null) {
+    async setHeaders(headers, options) {
         const data = { apiVersion: '1.0', method: 'set', params: headers };
-        return this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+        return this._postJsonEncoded('/axis-cgi/customhttpheader.cgi', data, undefined, options);
     }
-    async getParameter(paramNames, proxy = null) {
-        const response = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+    async getParameter(paramNames, options) {
+        const response = await this._postUrlEncoded('/axis-cgi/param.cgi', {
             action: 'list',
             group: arrayToUrl(paramNames),
-        });
-        return parseParameters(await response.text());
+        }, options);
+        return VapixAPI.parseParameters(await response.text());
     }
-    async setParameter(params, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+    async setParameter(params, options) {
+        const res = await this._postUrlEncoded('/axis-cgi/param.cgi', {
             ...params,
             action: 'update',
-        });
+        }, options);
         const responseText = await res.text();
         if (responseText.startsWith('# Error')) {
-            throw new Error(responseText);
+            throw new SettingParameterError(responseText);
         }
-        return true;
     }
-    async getGuardTourList(proxy = null) {
+    async getGuardTourList(options) {
         const gTourList = new Array();
-        const response = await this.getParameter('GuardTour', proxy);
+        const response = await this.getParameter('GuardTour', options);
         for (let i = 0; i < 20; i++) {
-            const gTourBaseName = 'root.GuardTour.G' + i;
+            const gTourBaseName = 'GuardTour.G' + i;
             if (gTourBaseName + '.CamNbr' in response) {
                 const gTour = {
                     id: gTourBaseName,
@@ -238,7 +271,7 @@ export class VapixAPI {
                     tour: [],
                 };
                 for (let j = 0; j < 100; j++) {
-                    const tourBaseName = 'root.GuardTour.G' + i + '.Tour.T' + j;
+                    const tourBaseName = 'GuardTour.G' + i + '.Tour.T' + j;
                     if (tourBaseName + '.MoveSpeed' in response) {
                         const tour = {
                             moveSpeed: response[tourBaseName + '.MoveSpeed'],
@@ -256,18 +289,18 @@ export class VapixAPI {
                 break;
             }
         }
-        return gTourList;
+        return guardTourSchema.parse(gTourList);
     }
-    setGuardTourEnabled(guardTourID, enable, proxy = null) {
-        const options = {};
-        options[guardTourID + '.Running'] = enable ? 'yes' : 'no';
-        return this.setParameter(options, proxy);
+    setGuardTourEnabled(guardTourId, enable, options) {
+        const params = {};
+        params[guardTourId + '.Running'] = enable ? 'yes' : 'no';
+        return this.setParameter(params, options);
     }
-    async getPTZPresetList(channel, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async getPTZPresetList(channel, options) {
+        const res = await this._postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposcam',
-            camera: channel.toString(),
-        });
+            camera: channel,
+        }, options);
         const text = await res.text();
         const lines = text.split(/[\r\n]/);
         const positions = [];
@@ -280,68 +313,131 @@ export class VapixAPI {
                 }
             }
         }
-        return positions;
+        return z.array(z.string()).parse(positions);
     }
-    async listPTZ(camera, proxy = null) {
+    async listPTZ(camera, options) {
         const url = `/axis-cgi/com/ptz.cgi`;
-        const response = await this.getUrlEncoded(proxy, url, {
+        const response = await this._postUrlEncoded(url, {
             camera,
             query: 'presetposcamdata',
             format: 'json',
-        });
+        }, options);
         const text = await response.text();
         if (text === '') {
             throw new PtzNotSupportedError();
         }
-        return parseCameraPtzResponse(text)[camera] ?? [];
+        return VapixAPI.parseCameraPtzResponse(text)[camera] ?? [];
     }
-    async listPtzVideoSourceOverview(proxy = null) {
-        const response = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async listPtzVideoSourceOverview(options) {
+        const response = await this._postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposall',
             format: 'json',
-        });
+        }, options);
         const text = await response.text();
         if (text === '') {
             throw new PtzNotSupportedError();
         }
-        const data = parseCameraPtzResponse(text);
+        const data = VapixAPI.parseCameraPtzResponse(text);
         const res = {};
         Object.keys(data)
             .map(Number)
             .forEach((camera) => {
-            if (data[camera] !== undefined) {
-                res[camera - 1] = data[camera]?.map(({ data: itemData, ...d }) => d);
+            const item = data[camera];
+            if (item !== undefined) {
+                res[camera - 1] = item.map(({ data: itemData, ...d }) => d);
             }
         });
-        return res;
+        return ptzOverviewSchema.parse(res);
     }
-    goToPreset(channel, presetName, proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    goToPreset(channel, presetName, options) {
+        return this._postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             camera: channel.toString(),
             gotoserverpresetname: presetName,
-        });
+        }, options);
     }
-    async getPtzPosition(camera, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async getPtzPosition(camera, options) {
+        const res = await this._postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'position',
             camera: camera.toString(),
-        });
-        const params = parseParameters(await res.text());
-        return {
+        }, options);
+        const params = VapixAPI.parseParameters(await res.text());
+        return cameraPTZItemDataSchema.parse({
             pan: Number(params.pan),
             tilt: Number(params.tilt),
             zoom: Number(params.zoom),
-        };
-    }
-    async getInputState(port, proxy = null) {
-        const response = await (await this.getUrlEncoded(proxy, '/axis-cgi/io/port.cgi', { checkactive: port.toString() })).text();
-        return response.split('=')[1]?.indexOf('active') === 0;
-    }
-    async setOutputState(port, active, proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/io/port.cgi', { action: active ? `${port}:/` : `${port}:\\` });
+        });
     }
-    async getApplicationList(proxy = null) {
-        const res = await this.client.get(proxy, '/axis-cgi/applications/list.cgi');
+    async getPorts(options) {
+        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;
+    }
+    async setPorts(ports, options) {
+        await this._postJsonEncoded('/axis-cgi/io/portmanagement.cgi', {
+            apiVersion: '1.0',
+            context: '',
+            method: 'setPorts',
+            params: { ports },
+        }, undefined, options);
+    }
+    async setPortStateSequence(port, sequence, options) {
+        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) {
+        return await this._postUrlEncoded('/axis-cgi/pwdgrp.cgi', {
+            action: 'add',
+            user: username,
+            pwd: pass,
+            grp: 'users',
+            sgrp,
+            comment,
+        }, options);
+    }
+    async getCameraUsers(options) {
+        const res = await this._postUrlEncoded('/axis-cgi/pwdgrp.cgi', {
+            action: 'get',
+        }, options);
+        return await res.text();
+    }
+    async editCameraUser(username, pass, options) {
+        return await this._postUrlEncoded('/axis-cgi/pwdgrp.cgi', {
+            action: 'update',
+            user: username,
+            pwd: pass,
+        }, options);
+    }
+    async getRecordingRuleList(options) {
+        const res = await this._getText('/axis-cgi/record/continuous/listconfiguration.cgi', undefined, options);
+        return VapixAPI.parseXmlResponse(res, 'continuousrecordingconfigurations');
+    }
+    async addRecordingRule(params, options) {
+        const res = await this._getText('/axis-cgi/record/continuous/addconfiguration.cgi', params, options);
+        return VapixAPI.parseXmlResponse(res, 'configure');
+    }
+    async removeRecordingRule(profileId, options) {
+        const res = await this._getText('/axis-cgi/record/continuous/removeconfiguration.cgi', {
+            profile: profileId,
+        }, options);
+        return VapixAPI.parseXmlResponse(res, 'remove');
+    }
+    async getDiskInfo(diskId = 'all', options) {
+        const res = await this._getText('/axis-cgi/disks/list.cgi', {
+            diskid: diskId,
+        }, options);
+        return VapixAPI.parseXmlResponse(res, 'disks');
+    }
+    async getApplicationList(options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path: '/axis-cgi/applications/list.cgi', timeout: options?.timeout });
         const xml = await res.text();
         const parser = new XMLParser({
             ignoreAttributes: false,
@@ -349,121 +445,155 @@ export class VapixAPI {
             allowBooleanAttributes: true,
         });
         const result = parser.parse(xml);
-        return result.reply.application.map((app) => {
+        let apps = result.reply.application ?? [];
+        if (!Array.isArray(apps)) {
+            apps = [apps];
+        }
+        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,
             };
         });
-    }
-    async startApplication(applicationID, proxy = null) {
-        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
-            package: applicationID.toLowerCase(),
-            action: 'start',
+        return applicationListSchema.parse(appList);
+    }
+    async startApplication(applicationId, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationId.toLowerCase(),
+                action: 'start',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
-            throw new ApplicationAPIError('START', await responseStringify(res));
+            throw new ApplicationAPIError('START', text);
         }
     }
-    async restartApplication(applicationID, proxy = null) {
-        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
-            package: applicationID.toLowerCase(),
-            action: 'restart',
+    async restartApplication(applicationId, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationId.toLowerCase(),
+                action: 'restart',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok') {
-            throw new ApplicationAPIError('RESTART', await responseStringify(res));
+            throw new ApplicationAPIError('RESTART', text);
         }
     }
-    async stopApplication(applicationID, proxy = null) {
-        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
-            package: applicationID.toLowerCase(),
-            action: 'stop',
+    async stopApplication(applicationId, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationId.toLowerCase(),
+                action: 'stop',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
-            throw new ApplicationAPIError('STOP', await responseStringify(res));
+            throw new ApplicationAPIError('STOP', text);
         }
     }
-    async installApplication(data, fileName) {
-        const formData = new FormData();
+    async installApplication(data, fileName, options) {
+        const formData = new this.CustomFormData();
         formData.append('packfil', data, fileName);
-        const res = await this.client.post(null, '/axis-cgi/applications/upload.cgi', formData, {}, {
-            contentType: 'application/octet-stream',
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({
+            path: '/axis-cgi/applications/upload.cgi',
+            data: formData,
+            headers: {
+                contentType: 'application/octet-stream',
+            },
+            timeout: options?.timeout ?? 300000,
         });
         if (!res.ok) {
-            throw new Error(await responseStringify(res));
+            throw new ErrorWithResponse(res);
         }
         const text = await res.text();
         if (text.length > 5) {
-            throw new Error('installing error: ' + text);
-        }
-    }
-}
-const parseParameters = (response) => {
-    const params = {};
-    const lines = response.split(/[\r\n]/);
-    for (const line of lines) {
-        if (line.length === 0 || line.substring(0, 7) === '# Error') {
-            continue;
-        }
-        const delimiterPos = line.indexOf('=');
-        if (delimiterPos !== -1) {
-            const paramName = line.substring(0, delimiterPos).replace('root.', '');
-            const paramValue = line.substring(delimiterPos + 1);
-            params[paramName] = paramValue;
+            throw new ApplicationAPIError('INSTALL', text);
         }
     }
-    return params;
-};
-const parseCameraPtzResponse = (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] = parsePtz(json[key].presets);
-        }
-    });
-    return parsed;
-};
-const parsePtz = (parsed) => {
-    const res = [];
-    parsed.forEach((value) => {
-        const delimiterPos = value.indexOf('=');
-        if (delimiterPos === -1) {
-            return;
-        }
-        if (!value.startsWith('presetposno')) {
-            return;
-        }
-        const id = Number(value.substring(11, delimiterPos));
-        if (Number.isNaN(id)) {
-            return;
+    static parseParameters = (response) => {
+        const params = {};
+        const lines = response.split(/[\r\n]/);
+        for (const line of lines) {
+            if (line.length === 0 || line.substring(0, 7) === '# Error') {
+                continue;
+            }
+            const delimiterPos = line.indexOf('=');
+            if (delimiterPos !== -1) {
+                const paramName = line.substring(0, delimiterPos).replace('root.', '');
+                const paramValue = line.substring(delimiterPos + 1);
+                params[paramName] = paramValue;
+            }
         }
-        const data = value.substring(delimiterPos + 1).split(':');
-        const getValue = (valueName) => {
-            for (const d of data) {
-                const p = d.split('=');
-                if (p[0] === valueName) {
-                    return Number(p[1]);
-                }
+        return params;
+    };
+    static parseCameraPtzResponse = (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] = VapixAPI.parsePtz(json[key].presets);
             }
-            return 0;
-        };
-        res.push({
-            id,
-            name: data[0] ?? 'Preset ' + id,
-            data: {
-                pan: getValue('pan'),
-                tilt: getValue('tilt'),
-                zoom: getValue('zoom'),
-            },
         });
-    });
-    return res;
-};
+        return parsed;
+    };
+    static parsePtz = (parsed) => {
+        const res = [];
+        parsed.forEach((value) => {
+            const delimiterPos = value.indexOf('=');
+            if (delimiterPos === -1) {
+                return;
+            }
+            if (!value.startsWith('presetposno')) {
+                return;
+            }
+            const id = Number(value.substring(11, delimiterPos));
+            if (Number.isNaN(id)) {
+                return;
+            }
+            const data = value.substring(delimiterPos + 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] ?? 'Preset ' + id,
+                data: {
+                    pan: getValue('pan'),
+                    tilt: getValue('tilt'),
+                    zoom: getValue('zoom'),
+                },
+            });
+        });
+        return res;
+    };
+    static parseXmlResponse = (xml, nodeName) => {
+        const doc = new DOMParser().parseFromString(xml, 'text/xml');
+        const node = doc.getElementsByTagName(nodeName);
+        if (node.length !== 1) {
+            throw new Error('Invalid XML from camera');
+        }
+        return node[0];
+    };
+}