camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.21

package/cjs/VapixAPI.js

@@ -0,0 +1,491 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VapixAPI = void 0;
+const prettifyXml = require("prettify-xml");
+const utils_1 = require("./internal/utils");
+const VapixAPI_1 = require("./types/VapixAPI");
+const errors_1 = require("./errors/errors");
+const ProxyClient_1 = require("./internal/ProxyClient");
+const zod_1 = require("zod");
+const fast_xml_parser_1 = require("fast-xml-parser");
+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, utils_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, utils_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, utils_1.responseStringify)(res));
+        }
+        const declarations = await res.text();
+        return prettifyXml(declarations);
+    }
+    async getSupportedAudioSampleRate(proxy = null) {
+        const url = '/axis-cgi/audio/streamingcapabilities.cgi';
+        const jsonData = { apiVersion: '1.0', method: 'list' };
+        const res = await this.postJson(proxy, url, jsonData);
+        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.getUrlEncoded(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 xmlText = await res.text();
+        const parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const result = parser.parse(xmlText);
+        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 textXml = await res.text();
+        const parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const result = parser.parse(textXml);
+        const job = result.root.job;
+        if (job.result !== 'OK') {
+            throw new errors_1.SDCardActionError(action, await (0, utils_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 textXml = await res.text();
+        const parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const job = parser.parse(textXml).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, utils_1.isNullish)(captureMode.maxFPS)) {
+            throw new errors_1.MaxFPSError('FPS_NOT_SPECIFIED');
+        }
+        return captureMode.maxFPS;
+    }
+    async getTimezone(proxy = null) {
+        try {
+            const resV2 = await this.client.get(proxy, '/config/rest/time/v2/timeZone');
+            if (!resV2.ok) {
+                throw new Error(await (0, utils_1.responseStringify)(resV2));
+            }
+            const json = await resV2.json();
+            const data = VapixAPI_1.timeZoneSchema.parse(json);
+            if (data.status === 'error') {
+                throw new Error(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(proxy);
+        if (data.data.timeZone === undefined) {
+            throw new Error('Time zone not setup on the device');
+        }
+        return data.data.timeZone;
+    }
+    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.data.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 json = await res.json();
+        if ((0, utils_1.isNullish)(json.data)) {
+            throw new errors_1.NoDeviceInfoError();
+        }
+        return json.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',
+        });
+        const text = await response.text();
+        if (text === '') {
+            throw new errors_1.PtzNotSupportedError();
+        }
+        return parseCameraPtzResponse(text)[camera] ?? [];
+    }
+    async listPtzVideoSourceOverview(proxy = null) {
+        const response = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+            query: 'presetposall',
+            format: 'json',
+        });
+        const text = await response.text();
+        if (text === '') {
+            throw new errors_1.PtzNotSupportedError();
+        }
+        const data = 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);
+            }
+        });
+        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.client.get(proxy, '/axis-cgi/applications/list.cgi');
+        const xml = await res.text();
+        const parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            allowBooleanAttributes: true,
+        });
+        const result = parser.parse(xml);
+        return result.reply.application.map((app) => {
+            return {
+                ...app,
+                appId: VapixAPI_1.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',
+        });
+        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, utils_1.responseStringify)(res));
+        }
+    }
+    async restartApplication(applicationID, proxy = null) {
+        const res = await this.client.get(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, utils_1.responseStringify)(res));
+        }
+    }
+    async stopApplication(applicationID, proxy = null) {
+        const res = await this.client.get(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, utils_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, utils_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).replace('root.', '');
+            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;
+};

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

@@ -1,5 +1,5 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { WsOptions } from './internal/common';
+import { WsOptions } from './internal/types';
 export type VapixEventsOptions = WsOptions;
 type TEventMessage = {
     apiVersion: string;

package/cjs/VapixEvents.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VapixEvents = void 0;
+const eventemitter2_1 = require("eventemitter2");
+const WsClient_1 = require("./node/WsClient");
+class VapixEvents extends eventemitter2_1.EventEmitter2 {
+    tls;
+    tlsInsecure;
+    ip;
+    port;
+    user;
+    pass;
+    ws;
+    constructor(options = {}) {
+        super();
+        this.tls = options.tls ?? false;
+        this.tlsInsecure = options.tlsInsecure ?? false;
+        this.ip = options.ip ?? '127.0.0.1';
+        this.port = options.port ?? (this.tls ? 443 : 80);
+        this.user = options.user ?? 'root';
+        this.pass = options.pass ?? '';
+        this.createWsClient();
+        eventemitter2_1.EventEmitter2.call(this);
+    }
+    connect() {
+        this.ws.open();
+    }
+    disconnect() {
+        this.ws.close();
+    }
+    createWsClient() {
+        const options = {
+            tls: this.tls,
+            tlsInsecure: this.tlsInsecure,
+            user: this.user,
+            pass: this.pass,
+            ip: this.ip,
+            port: this.port,
+            address: '/vapix/ws-data-stream?sources=events',
+        };
+        this.ws = new WsClient_1.WsClient(options);
+        this.ws.on('open', () => {
+            const topics = [];
+            const eventNames = this.eventNames();
+            for (const eventName of eventNames) {
+                if (!this.isReservedEventName(eventName)) {
+                    const topic = {
+                        topicFilter: eventName,
+                    };
+                    topics.push(topic);
+                }
+            }
+            const topicFilter = {
+                apiVersion: '1.0',
+                method: 'events:configure',
+                params: {
+                    eventFilterList: topics,
+                },
+            };
+            this.ws.send(JSON.stringify(topicFilter));
+        });
+        this.ws.on('message', (data) => {
+            const dataJSON = JSON.parse(data.toString());
+            if (dataJSON.method === 'events:configure') {
+                if (dataJSON.error === undefined) {
+                    this.emit('open');
+                }
+                else {
+                    this.emit('error', dataJSON.error);
+                    this.disconnect();
+                }
+                return;
+            }
+            const eventName = dataJSON.params.notification.topic;
+            this.emit(eventName, dataJSON);
+        });
+        this.ws.on('error', (error) => {
+            this.emit('error', error);
+        });
+        this.ws.on('close', () => {
+            this.emit('close');
+        });
+    }
+    isReservedEventName(eventName) {
+        return eventName === 'open' || eventName === 'close' || eventName === 'error';
+    }
+}
+exports.VapixEvents = VapixEvents;

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

@@ -31,4 +31,7 @@ export declare class FetchDeviceInfoError extends Error {
 export declare class AddNewClipError extends Error {
     constructor(message: string);
 }
+export declare class PtzNotSupportedError extends Error {
+    constructor();
+}
 export {};

package/cjs/errors/errors.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PtzNotSupportedError = exports.AddNewClipError = exports.FetchDeviceInfoError = exports.NoDeviceInfoError = exports.MaxFPSError = exports.SDCardJobError = exports.SDCardActionError = exports.ApplicationAPIError = exports.ParsingBlobError = exports.ServiceNotFoundError = exports.ServiceUnavailableError = void 0;
+class ServiceUnavailableError extends Error {
+    constructor() {
+        super('Service is unavailable.');
+        this.name = 'ServiceUnavailableError';
+    }
+}
+exports.ServiceUnavailableError = ServiceUnavailableError;
+class ServiceNotFoundError extends Error {
+    constructor() {
+        super('Service not found.');
+        this.name = 'ServiceNotFoundError';
+    }
+}
+exports.ServiceNotFoundError = ServiceNotFoundError;
+class ParsingBlobError extends Error {
+    constructor(err) {
+        super('Error parsing response as Blob: ' + err);
+        this.name = 'ParsingBlobError';
+    }
+}
+exports.ParsingBlobError = ParsingBlobError;
+class ApplicationAPIError extends Error {
+    constructor(action, res) {
+        super(`[APP ${action}] Error: ` + res);
+        this.name = 'ApplicationAPIError';
+    }
+}
+exports.ApplicationAPIError = ApplicationAPIError;
+class SDCardActionError extends Error {
+    constructor(action, res) {
+        super(`[SD_CARD ${action}] Error: ` + res);
+        this.name = 'SDCardActionError';
+    }
+}
+exports.SDCardActionError = SDCardActionError;
+class SDCardJobError extends Error {
+    constructor() {
+        super('Error while fetching SD card job progress');
+        this.name = 'SDCardJobError';
+    }
+}
+exports.SDCardJobError = SDCardJobError;
+const MAX_FPS_ERROR_MESSAGES = {
+    MALFORMED_REPLY: 'Malformed reply from camera',
+    CHANNEL_NOT_FOUND: 'Video channel not found.',
+    CAPTURE_MODE_NOT_FOUND: 'No enabled capture mode found.',
+    FPS_NOT_SPECIFIED: 'Max fps not specified for given capture mode.',
+};
+class MaxFPSError extends Error {
+    constructor(state) {
+        super(`[MAX_FPS ${state}] Error: ` + MAX_FPS_ERROR_MESSAGES[state]);
+        this.name = 'MaxFPSError';
+    }
+}
+exports.MaxFPSError = MaxFPSError;
+class NoDeviceInfoError extends Error {
+    constructor() {
+        super('Did not get any data from remote camera');
+        this.name = 'NoDeviceInfoError';
+    }
+}
+exports.NoDeviceInfoError = NoDeviceInfoError;
+class FetchDeviceInfoError extends Error {
+    constructor(err) {
+        super('Error fetching remote camera data: ' + err);
+        this.name = 'NoDeviceInfoFromCameraError';
+    }
+}
+exports.FetchDeviceInfoError = FetchDeviceInfoError;
+class AddNewClipError extends Error {
+    constructor(message) {
+        super('Error adding new clip: ' + message);
+        this.name = 'AddNewClipError';
+    }
+}
+exports.AddNewClipError = AddNewClipError;
+class PtzNotSupportedError extends Error {
+    constructor() {
+        super('Ptz not supported.');
+        this.name = 'PtzNotSupportedError';
+    }
+}
+exports.PtzNotSupportedError = PtzNotSupportedError;