camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.4

package/cjs/CreatePackage.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AdmZip = require("adm-zip");
+const Path = require("path");
+const fs = require("fs");
+const child_process_1 = require("child_process");
+const productionModulesFolder = 'production_modules';
+function isDirectory(path) {
+    const stat = fs.statSync(path);
+    return stat.isDirectory();
+}
+function getPackageInfo(folder) {
+    try {
+        const manifest = fs.readFileSync(Path.join(folder, 'manifest.json'));
+        const manifestParsed = JSON.parse(manifest.toString());
+        return {
+            packageName: manifestParsed.package_name,
+            packageVersion: manifestParsed.package_version.replace(/\./g, '_'),
+        };
+    }
+    catch (err) {
+        console.error('Get package version:', err);
+    }
+}
+function createZipArchive(zip, folder, options) {
+    const zipFileRegex = new RegExp(`${Path.basename(folder)}(_[0-9]){3}\\.zip`);
+    const files = fs.readdirSync(folder);
+    for (const file of files) {
+        const path = Path.join(folder, file);
+        const isDir = isDirectory(path);
+        if (file[0] === '.' ||
+            zipFileRegex.test(file) ||
+            file === 'node_modules' ||
+            (file === 'src' && options.typeScriptPackage) ||
+            options.excludedFileNames.includes(file)) {
+            continue;
+        }
+        else if (file === 'dist' && options.typeScriptPackage) {
+            zip.addLocalFolder(path);
+        }
+        else if (file === productionModulesFolder && options.includeNodeModules) {
+            zip.addLocalFolder(Path.join(productionModulesFolder, 'node_modules'), 'node_modules');
+        }
+        else if (isDir) {
+            zip.addLocalFolder(path, file);
+        }
+        else {
+            zip.addLocalFile(path);
+        }
+    }
+}
+function installDependencies() {
+    if (!fs.existsSync(productionModulesFolder)) {
+        fs.mkdirSync(productionModulesFolder, {});
+    }
+    fs.cpSync('package.json', Path.join(productionModulesFolder, 'package.json'));
+    fs.cpSync('package-lock.json', Path.join(productionModulesFolder, 'package-lock.json'));
+    (0, child_process_1.execSync)(`npm ci --omit=dev`, {
+        cwd: Path.join(process.cwd(), productionModulesFolder),
+    });
+}
+function main(args) {
+    const options = {
+        includeNodeModules: false,
+        typeScriptPackage: false,
+        outputFolder: '.',
+        excludedFileNames: [],
+    };
+    for (const arg of args) {
+        if (arg === '-i' || arg === '-includeNodeModules') {
+            options.includeNodeModules = true;
+        }
+        if (arg.startsWith('-w=') || arg.startsWith('-where=')) {
+            options.outputFolder = arg.substring(arg.indexOf('=') + 1);
+        }
+        if (arg.startsWith('-e=') || arg.startsWith('-exclude=')) {
+            options.excludedFileNames = arg.substring(arg.indexOf('=') + 1).split(',');
+        }
+    }
+    if (options.includeNodeModules) {
+        installDependencies();
+    }
+    if (fs.existsSync('dist')) {
+        options.typeScriptPackage = true;
+    }
+    const folder = Path.resolve('.');
+    const packageInfo = getPackageInfo(folder);
+    if (packageInfo === undefined) {
+        console.error('Package info not found');
+        process.exit(1);
+    }
+    const zipFile = `${options.outputFolder}/${packageInfo.packageName}_${packageInfo.packageVersion}.zip`;
+    if (fs.existsSync(zipFile)) {
+        try {
+            fs.unlinkSync(zipFile);
+        }
+        catch (error) {
+            console.error('An error occured: ', error);
+            process.exit(1);
+        }
+    }
+    const zip = new AdmZip();
+    createZipArchive(zip, folder, options);
+    zip.writeZip(zipFile);
+}
+main(process.argv.slice(2));

package/{VapixAPI.d.ts → cjs/VapixAPI.d.ts}

@@ -1,13 +1,13 @@
-import { IClient, TParameters, TResponse } from './internal/common';
+import { IClient, TParameters } from './internal/common';
 import { TApplication, TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice } from './types/VapixAPI';
 import { ProxyClient } from './internal/ProxyClient';
 import { TCameraImageConfig, TProxyParam } from './types/common';
 export declare class VapixAPI<Client extends IClient = IClient> {
     client: ProxyClient<Client>;
     constructor(client: Client, getProxyUrl: () => string);
-    getUrlEncoded(proxy: TProxyParam | undefined, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
-    postJson(proxy: TProxyParam | undefined, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<TResponse>;
-    getCameraImage(params: TCameraImageConfig, proxy?: TProxyParam): Promise<TResponse>;
+    getUrlEncoded(proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<import("./internal/common").TResponse>;
+    postJson(proxy: TProxyParam, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<import("./internal/common").TResponse>;
+    getCameraImage(params: TCameraImageConfig, proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
     getEventDeclarations(proxy?: TProxyParam): Promise<string>;
     getSupportedAudioSampleRate(proxy?: TProxyParam): Promise<TAudioSampleRates[]>;
     performAutofocus(proxy?: TProxyParam): Promise<void>;
@@ -16,8 +16,8 @@ export declare class VapixAPI<Client extends IClient = IClient> {
     unmountSDCard(proxy?: TProxyParam): Promise<number>;
     private _doSDCardMountAction;
     fetchSDCardJobProgress(jobId: number, proxy?: TProxyParam): Promise<number>;
-    downloadCameraReport(proxy?: TProxyParam): Promise<TResponse>;
-    getSystemLog(proxy?: TProxyParam): Promise<TResponse>;
+    downloadCameraReport(proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
+    getSystemLog(proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
     getMaxFps(channel: number, proxy?: TProxyParam): Promise<number>;
     getTimezone(proxy?: TProxyParam): Promise<string>;
     getDateTimeInfo(proxy?: TProxyParam): Promise<{
@@ -32,7 +32,7 @@ export declare class VapixAPI<Client extends IClient = IClient> {
     getDevicesSettings(proxy?: TProxyParam): Promise<TAudioDevice[]>;
     fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, proxy?: TProxyParam): Promise<any>;
     getHeaders(proxy?: TProxyParam): Promise<Record<string, string>>;
-    setHeaders(headers: Record<string, string>, proxy?: TProxyParam): Promise<TResponse>;
+    setHeaders(headers: Record<string, string>, proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
     getParameter(paramNames: string | string[], proxy?: TProxyParam): Promise<Record<string, string>>;
     setParameter(params: Record<string, string | number | boolean>, proxy?: TProxyParam): Promise<boolean>;
     getGuardTourList(proxy?: TProxyParam): Promise<{
@@ -54,10 +54,10 @@ export declare class VapixAPI<Client extends IClient = IClient> {
     getPTZPresetList(channel: number, proxy?: TProxyParam): Promise<string[]>;
     listPTZ(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItem[]>;
     listPtzVideoSourceOverview(proxy?: TProxyParam): Promise<TPtzOverview>;
-    goToPreset(channel: number, presetName: string, proxy?: TProxyParam): Promise<TResponse>;
+    goToPreset(channel: number, presetName: string, proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
     getPtzPosition(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItemData>;
     getInputState(port: number, proxy?: TProxyParam): Promise<boolean>;
-    setOutputState(port: number, active: boolean, proxy?: TProxyParam): Promise<TResponse>;
+    setOutputState(port: number, active: boolean, proxy?: TProxyParam): Promise<import("./internal/common").TResponse>;
     getApplicationList(proxy?: TProxyParam): Promise<TApplication[]>;
     startApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
     restartApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;

package/cjs/VapixAPI.js

@@ -0,0 +1,462 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VapixAPI = void 0;
+const prettifyXml = require("prettify-xml");
+const xml2js_1 = require("xml2js");
+const common_1 = require("./internal/common");
+const VapixAPI_1 = require("./types/VapixAPI");
+const errors_1 = require("./errors/errors");
+const ProxyClient_1 = require("./internal/ProxyClient");
+const utils_1 = require("./internal/utils");
+const zod_1 = require("zod");
+class VapixAPI {
+    client;
+    constructor(client, getProxyUrl) {
+        this.client = new ProxyClient_1.ProxyClient(client, getProxyUrl);
+    }
+    async getUrlEncoded(proxy, path, parameters, headers = {}) {
+        const data = (0, utils_1.paramToUrl)(parameters);
+        const head = { ...headers, 'Content-Type': 'application/x-www-form-urlencoded' };
+        const res = await this.client.post(proxy, path, data, {}, head);
+        if (!res.ok) {
+            throw new Error(await (0, common_1.responseStringify)(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);
+        if (!res.ok) {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+        return res;
+    }
+    async getCameraImage(params, proxy = null) {
+        return await this.client.get(proxy, '/axis-cgi/jpg/image.cgi', params);
+    }
+    async getEventDeclarations(proxy = null) {
+        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' });
+        if (!res.ok) {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+        const declarations = await res.text();
+        return prettifyXml(declarations);
+    }
+    async getSupportedAudioSampleRate(proxy = null) {
+        const url = '/axis-cgi/audio/streamingcapabilities.cgi';
+        const formData = { apiVersion: '1.0', method: 'list' };
+        const res = await this.postJson(proxy, url, formData);
+        const encoders = VapixAPI_1.audioSampleRatesResponseSchema.parse(await res.json()).data.encoders;
+        const data = encoders.aac ?? encoders.AAC ?? [];
+        return data.map((item) => {
+            return {
+                sampleRate: item.sample_rate,
+                bitRates: item.bit_rates,
+            };
+        });
+    }
+    async performAutofocus(proxy = null) {
+        try {
+            const data = {
+                apiVersion: '1',
+                method: 'performAutofocus',
+                params: {
+                    optics: [
+                        {
+                            opticsId: '0',
+                        },
+                    ],
+                },
+            };
+            await this.postJson(proxy, '/axis-cgi/opticscontrol.cgi', data);
+        }
+        catch (err) {
+            await this.postJson(proxy, '/axis-cgi/opticssetup.cgi', {
+                autofocus: 'perform',
+                source: '1',
+            });
+        }
+    }
+    async checkSDCard(proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/list.cgi', {
+            diskid: 'SD_DISK',
+        });
+        const result = await (0, xml2js_1.parseStringPromise)(await res.text(), {
+            ignoreAttrs: false,
+            mergeAttrs: true,
+            explicitArray: false,
+        });
+        const data = result.root.disks.disk;
+        return {
+            totalSize: parseInt(data.totalsize),
+            freeSize: parseInt(data.freesize),
+            status: VapixAPI_1.sdCardWatchedStatuses.includes(data.status) ? data.status : 'disconnected',
+        };
+    }
+    mountSDCard(proxy = null) {
+        return this._doSDCardMountAction('MOUNT', proxy);
+    }
+    unmountSDCard(proxy = null) {
+        return this._doSDCardMountAction('UNMOUNT', proxy);
+    }
+    async _doSDCardMountAction(action, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/mount.cgi', {
+            action: action,
+            diskid: 'SD_DISK',
+        });
+        const result = await (0, xml2js_1.parseStringPromise)(await res.text(), {
+            ignoreAttrs: false,
+            mergeAttrs: true,
+            explicitArray: false,
+        });
+        const job = result.root.job;
+        if (job.result !== 'OK') {
+            throw new errors_1.SDCardActionError(action, await (0, common_1.responseStringify)(res));
+        }
+        return Number(job.jobid);
+    }
+    async fetchSDCardJobProgress(jobId, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/disks/job.cgi', {
+            jobid: String(jobId),
+            diskid: 'SD_DISK',
+        });
+        const result = await (0, xml2js_1.parseStringPromise)(await res.text(), {
+            ignoreAttrs: false,
+            mergeAttrs: true,
+            explicitArray: false,
+        });
+        const job = result.root.job;
+        if (job.result !== 'OK') {
+            throw new errors_1.SDCardJobError();
+        }
+        return Number(job.progress);
+    }
+    downloadCameraReport(proxy = null) {
+        return this.getUrlEncoded(proxy, '/axis-cgi/serverreport.cgi', { mode: 'text' });
+    }
+    getSystemLog(proxy = null) {
+        return this.getUrlEncoded(proxy, '/axis-cgi/admin/systemlog.cgi');
+    }
+    async getMaxFps(channel, proxy = null) {
+        const data = { apiVersion: '1.0', method: 'getCaptureModes' };
+        const res = await this.postJson(proxy, '/axis-cgi/capturemode.cgi', data);
+        const response = VapixAPI_1.maxFpsResponseSchema.parse(await res.json());
+        const channels = response.data;
+        if (channels === undefined) {
+            throw new errors_1.MaxFPSError('MALFORMED_REPLY');
+        }
+        const channelData = channels.find((x) => x.channel === channel);
+        if (channelData === undefined) {
+            throw new errors_1.MaxFPSError('CHANNEL_NOT_FOUND');
+        }
+        const captureModes = channelData.captureMode;
+        const captureMode = captureModes.find((x) => x.enabled === true);
+        if (captureMode === undefined) {
+            throw new errors_1.MaxFPSError('CAPTURE_MODE_NOT_FOUND');
+        }
+        if ((0, common_1.isNullish)(captureMode.maxFPS)) {
+            throw new errors_1.MaxFPSError('FPS_NOT_SPECIFIED');
+        }
+        return 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 getDateTimeInfo(proxy = null) {
+        const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
+        const res = await this.postJson(proxy, '/axis-cgi/time.cgi', data);
+        return VapixAPI_1.dateTimeinfoSchema.parse(await res.json());
+    }
+    async getDevicesSettings(proxy = null) {
+        const data = { apiVersion: '1.0', method: 'getDevicesSettings' };
+        const res = await this.postJson(proxy, '/axis-cgi/audiodevicecontrol.cgi', data);
+        const result = VapixAPI_1.audioDeviceRequestSchema.parse(await res.json());
+        return result.devices.map((device) => ({
+            ...device,
+            inputs: (device.inputs || []).sort((a, b) => a.id.localeCompare(b.id)),
+            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);
+        const result = await (0, xml2js_1.parseStringPromise)(await res.text(), {
+            ignoreAttrs: false,
+            mergeAttrs: true,
+            explicitArray: false,
+        });
+        if ((0, common_1.isNullish)(result.body.data)) {
+            throw new errors_1.NoDeviceInfoError();
+        }
+        return result.data;
+    }
+    async getHeaders(proxy = null) {
+        const data = { apiVersion: '1.0', method: 'list' };
+        const res = await this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+        return zod_1.z.object({ data: zod_1.z.record(zod_1.z.string()) }).parse(await res.json()).data;
+    }
+    async setHeaders(headers, proxy = null) {
+        const data = { apiVersion: '1.0', method: 'set', params: headers };
+        return this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+    }
+    async getParameter(paramNames, proxy = null) {
+        const response = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+            action: 'list',
+            group: (0, utils_1.arrayToUrl)(paramNames),
+        });
+        return parseParameters(await response.text());
+    }
+    async setParameter(params, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+            ...params,
+            action: 'update',
+        });
+        const responseText = await res.text();
+        if (responseText.startsWith('# Error')) {
+            throw new Error(responseText);
+        }
+        return true;
+    }
+    async getGuardTourList(proxy = null) {
+        const gTourList = new Array();
+        const response = await this.getParameter('GuardTour', proxy);
+        for (let i = 0; i < 20; i++) {
+            const gTourBaseName = 'root.GuardTour.G' + i;
+            if (gTourBaseName + '.CamNbr' in response) {
+                const gTour = {
+                    id: gTourBaseName,
+                    camNbr: response[gTourBaseName + '.CamNbr'],
+                    name: response[gTourBaseName + '.Name'] ?? 'Guard Tour ' + (i + 1),
+                    randomEnabled: response[gTourBaseName + '.RandomEnabled'],
+                    running: response[gTourBaseName + '.Running'] ?? 'no',
+                    timeBetweenSequences: response[gTourBaseName + '.TimeBetweenSequences'],
+                    tour: [],
+                };
+                for (let j = 0; j < 100; j++) {
+                    const tourBaseName = 'root.GuardTour.G' + i + '.Tour.T' + j;
+                    if (tourBaseName + '.MoveSpeed' in response) {
+                        const tour = {
+                            moveSpeed: response[tourBaseName + '.MoveSpeed'],
+                            position: response[tourBaseName + '.Position'],
+                            presetNbr: response[tourBaseName + '.PresetNbr'],
+                            waitTime: response[tourBaseName + '.WaitTime'],
+                            waitTimeViewType: response[tourBaseName + '.WaitTimeViewType'],
+                        };
+                        gTour.tour.push(tour);
+                    }
+                }
+                gTourList.push(gTour);
+            }
+            else {
+                break;
+            }
+        }
+        return gTourList;
+    }
+    setGuardTourEnabled(guardTourID, enable, proxy = null) {
+        const options = {};
+        options[guardTourID + '.Running'] = enable ? 'yes' : 'no';
+        return this.setParameter(options, proxy);
+    }
+    async getPTZPresetList(channel, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            query: 'presetposcam',
+            camera: channel.toString(),
+        });
+        const text = await res.text();
+        const lines = text.split(/[\r\n]/);
+        const positions = [];
+        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;
+    }
+    async listPTZ(camera, proxy = null) {
+        const url = `/axis-cgi/com/ptz.cgi`;
+        const response = await this.getUrlEncoded(proxy, url, {
+            camera,
+            query: 'presetposcamdata',
+            format: 'json',
+        });
+        return parseCameraPtzResponse(await response.text())[camera] ?? [];
+    }
+    async listPtzVideoSourceOverview(proxy = null) {
+        const response = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            query: 'presetposall',
+            format: 'json',
+        });
+        const data = parseCameraPtzResponse(await response.text());
+        const res = {};
+        Object.keys(data)
+            .map(Number)
+            .forEach((camera) => {
+            if (data[camera] !== undefined) {
+                res[camera - 1] = data[camera]?.map(({ data: itemData, ...d }) => d);
+            }
+        });
+        return res;
+    }
+    goToPreset(channel, presetName, proxy = null) {
+        return this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            camera: channel.toString(),
+            gotoserverpresetname: presetName,
+        });
+    }
+    async getPtzPosition(camera, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            query: 'position',
+            camera: camera.toString(),
+        });
+        const params = parseParameters(await res.text());
+        return {
+            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.getUrlEncoded(proxy, '/axis-cgi/applications/list.cgi');
+        const xml = await res.text();
+        const result = (await (0, xml2js_1.parseStringPromise)(xml));
+        const apps = [];
+        for (const app of result.reply.application) {
+            apps.push({
+                ...app.$,
+                appId: VapixAPI_1.APP_IDS.find((id) => id.toLowerCase() === app.$.Name.toLowerCase()) ?? null,
+            });
+        }
+        return apps;
+    }
+    async startApplication(applicationID, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+            package: applicationID.toLowerCase(),
+            action: 'start',
+        });
+        const text = (await res.text()).trim().toLowerCase();
+        if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
+            throw new errors_1.ApplicationAPIError('START', await (0, common_1.responseStringify)(res));
+        }
+    }
+    async restartApplication(applicationID, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+            package: applicationID.toLowerCase(),
+            action: 'restart',
+        });
+        const text = (await res.text()).trim().toLowerCase();
+        if (text !== 'ok') {
+            throw new errors_1.ApplicationAPIError('RESTART', await (0, common_1.responseStringify)(res));
+        }
+    }
+    async stopApplication(applicationID, proxy = null) {
+        const res = await this.getUrlEncoded(proxy, '/axis-cgi/applications/control.cgi', {
+            package: applicationID.toLowerCase(),
+            action: 'stop',
+        });
+        const text = (await res.text()).trim().toLowerCase();
+        if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
+            throw new errors_1.ApplicationAPIError('STOP', await (0, common_1.responseStringify)(res));
+        }
+    }
+    async installApplication(data, fileName) {
+        const formData = new FormData();
+        formData.append('packfil', data, fileName);
+        const res = await this.client.post(null, '/axis-cgi/applications/upload.cgi', formData, {}, {
+            contentType: 'application/octet-stream',
+        });
+        if (!res.ok) {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+        const text = await res.text();
+        if (text.length > 5) {
+            throw new Error('installing error: ' + text);
+        }
+    }
+}
+exports.VapixAPI = VapixAPI;
+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);
+            const paramValue = line.substring(delimiterPos + 1);
+            params[paramName] = paramValue;
+        }
+    }
+    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;
+        }
+        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;
+};