hoffmation-base 3.6.1 → 3.7.0

package/lib/devices/unifi/unifi-protect.d.ts

@@ -1,22 +1,53 @@
+import { OwnUnifiAirQualitySensor } from './own-unifi-air-quality-sensor';
 import { OwnUnifiCamera } from './own-unifi-camera';
 import { iDisposable, iUnifiProtectOptions } from '../../interfaces';
 export declare class UnifiProtect implements iDisposable {
     private readonly unifiLogger;
-    private readonly _api;
     /**
      * Mapping for own devices
      */
     static readonly ownCameras: Map<string, OwnUnifiCamera>;
-    private _deviceStates;
+    /**
+     * Mapping for own air quality sensors
+     */
+    static readonly ownAirQualitySensors: Map<string, OwnUnifiAirQualitySensor>;
+    private _client;
+    private _connecting;
+    private _disposed;
+    private _eventAbort;
     private _idMap;
-    private _eventMap;
-    private _lastUpdate;
+    private _ignoredIds;
+    private _sensorIdMap;
+    private _ignoredSensorIds;
     constructor(settings: iUnifiProtectOptions);
-    private reconnect;
+    /**
+     * Connects to the NVR. A single atomic operation which logs in, bootstraps and opens the realtime channel.
+     * @param settings - The address and credentials of the NVR
+     */
+    private connect;
+    /**
+     * Renders a typed `ProtectError` including its errno code and the whole cause chain,
+     * as the message alone rarely names the actual failure.
+     * @param error - The rejected value
+     * @returns A single line description
+     */
+    private static describeError;
     dispose(): void;
     static addDevice(camera: OwnUnifiCamera): void;
+    /**
+     * Registers an air quality sensor to be fed with the readings of its Unifi counterpart.
+     * @param sensor - The device to register
+     */
+    static addAirQualitySensor(sensor: OwnUnifiAirQualitySensor): void;
     private initialize;
-    private onMessage;
-    private rememberAddEvent;
+    /**
+     * Consumes the realtime firehose until the client is disposed or the stream dies.
+     * @param client - The connected client whose event stream is consumed
+     */
+    private consumeEvents;
+    private onEvent;
+    private forwardToCamera;
+    private ownSensorFor;
+    private initializeSensor;
     private initializeCamera;
 }

package/lib/devices/unifi/unifi-protect.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiProtect = void 0;
-const unifi_protect_1 = require("unifi-protect");
+const protect_module_1 = require("./protect-module");
 const enums_1 = require("../../enums");
 const logging_1 = require("../../logging");
 const utils_1 = require("../../utils");
@@ -9,105 +9,234 @@ const unifi_logger_1 = require("./unifi-logger");
 class UnifiProtect {
     constructor(settings) {
         this.unifiLogger = new unifi_logger_1.UnifiLogger(enums_1.LogSource.UnifiProtect);
-        this._deviceStates = new Map();
+        this._client = null;
+        this._connecting = false;
+        this._disposed = false;
+        this._eventAbort = null;
         this._idMap = new Map();
-        this._eventMap = new Map();
-        this._lastUpdate = new Date(0);
-        this._api = new unifi_protect_1.ProtectApi(this.unifiLogger);
-        this.reconnect(settings);
+        this._ignoredIds = new Set();
+        this._sensorIdMap = new Map();
+        this._ignoredSensorIds = new Set();
+        this.connect(settings);
         utils_1.Utils.guardedInterval(() => {
-            if (new Date().getTime() - this._lastUpdate.getTime() < 180 * 1000) {
-                // We had an update within the last 3 minutes --> no need to reconnect
+            if (this._disposed || this._connecting || this._client !== null) {
+                // Either shut down, already connecting or the client is up and recovers outages on its own.
                 return;
             }
-            this.reconnect(settings);
+            this.connect(settings);
         }, 5 * 60 * 1000);
     }
-    reconnect(settings) {
-        this._eventMap = new Map();
-        this._api
-            .login(settings.nvrAddress, settings.username, settings.password)
-            .then((_loggedIn) => {
-            this.initialize();
+    /**
+     * Connects to the NVR. A single atomic operation which logs in, bootstraps and opens the realtime channel.
+     * @param settings - The address and credentials of the NVR
+     */
+    connect(settings) {
+        this._connecting = true;
+        this._idMap = new Map();
+        this._ignoredIds = new Set();
+        this._sensorIdMap = new Map();
+        this._ignoredSensorIds = new Set();
+        (0, protect_module_1.loadProtectModule)()
+            .then((protect) => protect.ProtectClient.connect({
+            host: settings.nvrAddress,
+            username: settings.username,
+            password: settings.password,
+            log: this.unifiLogger,
+        }))
+            .then((client) => {
+            this._connecting = false;
+            if (this._disposed) {
+                void client[Symbol.asyncDispose]();
+                return;
+            }
+            this._client = client;
+            this.initialize(client);
         })
             .catch((error) => {
-            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `Unifi-Protect: Login failed: ${error}`);
+            this._connecting = false;
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `Unifi-Protect: Login failed: ${UnifiProtect.describeError(error)}`);
         });
     }
+    /**
+     * Renders a typed `ProtectError` including its errno code and the whole cause chain,
+     * as the message alone rarely names the actual failure.
+     * @param error - The rejected value
+     * @returns A single line description
+     */
+    static describeError(error) {
+        if (!(error instanceof Error)) {
+            return `${error}`;
+        }
+        const parts = [`${error.name}: ${error.message}`];
+        const code = Reflect.get(error, 'code');
+        if (typeof code === 'string') {
+            parts.push(`code: ${code}`);
+        }
+        let cause = error.cause;
+        while (cause instanceof Error) {
+            parts.push(`caused by ${cause.name}: ${cause.message}`);
+            cause = cause.cause;
+        }
+        return parts.join(' | ');
+    }
     dispose() {
-        this._api.logout();
+        var _a;
+        this._disposed = true;
+        (_a = this._eventAbort) === null || _a === void 0 ? void 0 : _a.abort();
+        this._eventAbort = null;
+        const client = this._client;
+        this._client = null;
+        client === null || client === void 0 ? void 0 : client[Symbol.asyncDispose]().catch((error) => {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `Unifi-Protect: Disposal failed: ${error}`);
+        });
     }
     static addDevice(camera) {
         this.ownCameras.set(camera.unifiCameraName, camera);
     }
-    async initialize() {
-        this.unifiLogger.info('Unifi-Protect: Login successful');
-        const bootstrap = await this._api.getBootstrap();
-        if (!bootstrap || !this._api.bootstrap) {
-            this.unifiLogger.error('Unifi-Protect: Bootstrap failed');
-            return;
-        }
-        const info = this._api.bootstrap;
-        for (const camera of info.cameras) {
+    /**
+     * Registers an air quality sensor to be fed with the readings of its Unifi counterpart.
+     * @param sensor - The device to register
+     */
+    static addAirQualitySensor(sensor) {
+        this.ownAirQualitySensors.set(sensor.unifiSensorName, sensor);
+    }
+    initialize(client) {
+        this.unifiLogger.info(`Unifi-Protect: Connected to "${client.controllerName}"`);
+        for (const camera of client.cameras) {
             this.initializeCamera(camera);
         }
-        this._api.on('message', this.onMessage.bind(this));
+        for (const sensor of client.sensors) {
+            this.initializeSensor(sensor);
+        }
+        void this.consumeEvents(client);
+    }
+    /**
+     * Consumes the realtime firehose until the client is disposed or the stream dies.
+     * @param client - The connected client whose event stream is consumed
+     */
+    async consumeEvents(client) {
+        const abort = new AbortController();
+        this._eventAbort = abort;
+        try {
+            for await (const event of client.events({ signal: abort.signal })) {
+                this.onEvent(client, event);
+            }
+        }
+        catch (error) {
+            if (!abort.signal.aborted) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `Unifi-Protect: Event stream failed: ${error}`);
+            }
+        }
+        if (this._client === client) {
+            // The stream is the client's lifeline --> drop it, so the interval reconnects.
+            this._client = null;
+            void client[Symbol.asyncDispose]();
+        }
     }
-    onMessage(packet) {
-        var _a, _b, _c, _d;
-        const payload = packet.payload;
-        this._lastUpdate = new Date();
-        switch (packet.header.modelKey) {
-            case 'nvr':
+    onEvent(client, event) {
+        switch (event.kind) {
+            case 'bootstrapLoaded':
+                for (const camera of client.cameras) {
+                    this.initializeCamera(camera);
+                }
+                for (const sensor of client.sensors) {
+                    this.initializeSensor(sensor);
+                }
                 break;
-            default:
-                // Lookup the device.
-                let id = packet.header.id;
-                let baseEvent;
-                if (packet.header.action === 'add') {
-                    const addEvent = packet.payload;
-                    id = (_a = addEvent.camera) !== null && _a !== void 0 ? _a : addEvent.cameraId;
-                    this.rememberAddEvent(packet, addEvent);
+            case 'deviceAdded': {
+                if (event.modelKey === 'camera') {
+                    const camera = client.camera(event.id);
+                    if (camera !== undefined) {
+                        this.initializeCamera(camera);
+                    }
                 }
-                else if (packet.header.action === 'update' && this._eventMap.has(id)) {
-                    baseEvent = this._eventMap.get(id);
-                    id = (_c = (_b = baseEvent === null || baseEvent === void 0 ? void 0 : baseEvent.camera) !== null && _b !== void 0 ? _b : baseEvent === null || baseEvent === void 0 ? void 0 : baseEvent.cameraId) !== null && _c !== void 0 ? _c : '';
+                else if (event.modelKey === 'sensor') {
+                    const sensor = client.sensor(event.id);
+                    if (sensor !== undefined) {
+                        this.initializeSensor(sensor);
+                    }
                 }
-                const ownName = this._idMap.get(id);
-                if (!ownName) {
+                break;
+            }
+            case 'devicePatched': {
+                if (event.modelKey !== 'sensor') {
                     break;
                 }
-                const ownCamera = UnifiProtect.ownCameras.get(ownName);
-                if (ownCamera !== undefined) {
+                // The patch carries the full airQuality block, but the projection is authoritative and always complete.
+                const ownSensor = this.ownSensorFor(event.id);
+                const sensor = client.sensor(event.id);
+                if (ownSensor !== undefined && sensor !== undefined) {
                     utils_1.Utils.guardedFunction(() => {
-                        ownCamera.update(packet, baseEvent);
+                        ownSensor.update(sensor.config);
                     }, this);
-                    break;
                 }
                 break;
+            }
+            case 'deviceRemoved':
+                this._idMap.delete(event.id);
+                this._ignoredIds.delete(event.id);
+                this._sensorIdMap.delete(event.id);
+                this._ignoredSensorIds.delete(event.id);
+                break;
+            case 'motionDetected':
+            case 'smartDetect':
+                this.forwardToCamera(event.cameraId, event);
+                break;
         }
-        // Update the internal list we maintain.
-        if (packet.header.action === 'update') {
-            this._deviceStates.set(packet.header.id, Object.assign((_d = this._deviceStates.get(packet.header.id)) !== null && _d !== void 0 ? _d : {}, payload));
+    }
+    forwardToCamera(cameraId, event) {
+        const ownName = this._idMap.get(cameraId);
+        if (!ownName) {
+            return;
+        }
+        const ownCamera = UnifiProtect.ownCameras.get(ownName);
+        if (ownCamera === undefined) {
+            return;
         }
+        utils_1.Utils.guardedFunction(() => {
+            ownCamera.update(event);
+        }, this);
     }
-    rememberAddEvent(packet, addEvent) {
-        if (packet.header.modelKey === 'event') {
-            this._eventMap.set(addEvent.id, addEvent);
-            utils_1.Utils.guardedTimeout(() => {
-                this._eventMap.delete(addEvent.id);
-            }, 5 * 60 * 1000, this);
+    ownSensorFor(sensorId) {
+        const ownName = this._sensorIdMap.get(sensorId);
+        if (!ownName) {
+            return undefined;
         }
+        return UnifiProtect.ownAirQualitySensors.get(ownName);
     }
-    initializeCamera(data) {
-        if (!data.name || !UnifiProtect.ownCameras.has(data.name)) {
-            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Unifi-Protect: Ignoring camera ${data.name}`);
+    initializeSensor(sensor) {
+        if (this._sensorIdMap.has(sensor.id) || this._ignoredSensorIds.has(sensor.id)) {
+            // Already known --> the projection is live, so there is nothing to refresh.
             return;
         }
-        const camera = UnifiProtect.ownCameras.get(data.name);
-        camera.initialize(data);
-        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Unifi-Protect: Camera ${data.name} (re)initialized`);
-        this._idMap.set(data.id, data.name);
+        const name = sensor.name;
+        if (!name || !UnifiProtect.ownAirQualitySensors.has(name)) {
+            this._ignoredSensorIds.add(sensor.id);
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Unifi-Protect: Ignoring sensor ${name}`);
+            return;
+        }
+        const ownSensor = UnifiProtect.ownAirQualitySensors.get(name);
+        this._sensorIdMap.set(sensor.id, name);
+        utils_1.Utils.guardedFunction(() => {
+            ownSensor.initialize(sensor);
+        }, this);
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Unifi-Protect: Sensor ${name} (re)initialized`);
+    }
+    initializeCamera(camera) {
+        if (this._idMap.has(camera.id) || this._ignoredIds.has(camera.id)) {
+            // Already known --> the projection is live, so there is nothing to refresh.
+            return;
+        }
+        const name = camera.name;
+        if (!name || !UnifiProtect.ownCameras.has(name)) {
+            this._ignoredIds.add(camera.id);
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Unifi-Protect: Ignoring camera ${name}`);
+            return;
+        }
+        const ownCamera = UnifiProtect.ownCameras.get(name);
+        ownCamera.initialize(camera);
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Unifi-Protect: Camera ${name} (re)initialized`);
+        this._idMap.set(camera.id, name);
     }
 }
 exports.UnifiProtect = UnifiProtect;
@@ -115,3 +244,7 @@ exports.UnifiProtect = UnifiProtect;
  * Mapping for own devices
  */
 UnifiProtect.ownCameras = new Map();
+/**
+ * Mapping for own air quality sensors
+ */
+UnifiProtect.ownAirQualitySensors = new Map();

package/lib/enums/DeviceCapability.d.ts

@@ -22,6 +22,7 @@ export declare enum DeviceCapability {
     loadMetering = 20,
     garageDoorOpener = 21,
     magnetSensor = 22,
+    airQualitySensor = 23,
     bluetoothDetector = 101,
     trackableDevice = 102,
     scene = 103,

package/lib/enums/DeviceCapability.js

@@ -26,6 +26,7 @@ var DeviceCapability;
     DeviceCapability[DeviceCapability["loadMetering"] = 20] = "loadMetering";
     DeviceCapability[DeviceCapability["garageDoorOpener"] = 21] = "garageDoorOpener";
     DeviceCapability[DeviceCapability["magnetSensor"] = 22] = "magnetSensor";
+    DeviceCapability[DeviceCapability["airQualitySensor"] = 23] = "airQualitySensor";
     DeviceCapability[DeviceCapability["bluetoothDetector"] = 101] = "bluetoothDetector";
     DeviceCapability[DeviceCapability["trackableDevice"] = 102] = "trackableDevice";
     DeviceCapability[DeviceCapability["scene"] = 103] = "scene";

package/lib/enums/commandType.d.ts

@@ -14,6 +14,7 @@ export declare enum CommandType {
     ActuatorWriteStateToDeviceCommand = "ActuatorWriteStateToDeviceCommand",
     DimmerSetLightCommand = "DimmerSetLightCommand",
     FloorSetAllShuttersCommand = "FloorSetAllShuttersCommand",
+    AirQualitySensorChangeAction = "AirQualitySensorChangeAction",
     HumiditySensorChangeAction = "HumiditySensorChangeAction",
     LampSetLightCommand = "LampSetLightCommand",
     LampSetTimeBasedCommand = "LampSetTimeBasedCommand",

package/lib/enums/commandType.js

@@ -18,6 +18,7 @@ var CommandType;
     CommandType["ActuatorWriteStateToDeviceCommand"] = "ActuatorWriteStateToDeviceCommand";
     CommandType["DimmerSetLightCommand"] = "DimmerSetLightCommand";
     CommandType["FloorSetAllShuttersCommand"] = "FloorSetAllShuttersCommand";
+    CommandType["AirQualitySensorChangeAction"] = "AirQualitySensorChangeAction";
     CommandType["HumiditySensorChangeAction"] = "HumiditySensorChangeAction";
     CommandType["LampSetLightCommand"] = "LampSetLightCommand";
     CommandType["LampSetTimeBasedCommand"] = "LampSetTimeBasedCommand";

package/lib/enums/deviceType.d.ts

@@ -58,6 +58,7 @@ export declare enum DeviceType {
     TrackableDevice = 4002,
     Camera = 6001,
     Door = 6002,
+    UnifiAirQualitySensor = 6003,
     Victron = 7001,
     Dachs = 7002,
     DachsWarmWaterTemperature = 7003

package/lib/enums/deviceType.js

@@ -62,6 +62,7 @@ var DeviceType;
     DeviceType[DeviceType["TrackableDevice"] = 4002] = "TrackableDevice";
     DeviceType[DeviceType["Camera"] = 6001] = "Camera";
     DeviceType[DeviceType["Door"] = 6002] = "Door";
+    DeviceType[DeviceType["UnifiAirQualitySensor"] = 6003] = "UnifiAirQualitySensor";
     DeviceType[DeviceType["Victron"] = 7001] = "Victron";
     DeviceType[DeviceType["Dachs"] = 7002] = "Dachs";
     DeviceType[DeviceType["DachsWarmWaterTemperature"] = 7003] = "DachsWarmWaterTemperature";

package/lib/interfaces/baseDevices/iAirQualityCollector.d.ts

@@ -0,0 +1,23 @@
+import { iRoomDevice } from './iRoomDevice';
+import { AirQualitySensorChangeAction } from '../../action';
+import { iAirQualityReadings, iAirQualitySensor } from './iAirQualitySensor';
+/**
+ * This interface represents a device measuring air quality.
+ *
+ * For devices with {@link DeviceCapability.airQualitySensor} capability.
+ */
+export interface iAirQualityCollector extends iRoomDevice {
+    /**
+     * Service which handles common aspects of the air quality sensor like persisting
+     */
+    readonly airQualitySensor: iAirQualitySensor;
+    /**
+     * The most recent air quality readings of this device
+     */
+    readonly airQuality: iAirQualityReadings;
+    /**
+     * Add a callback that is called when any air quality reading changes
+     * @param pCallback - The callback to fire
+     */
+    addAirQualityCallback(pCallback: (action: AirQualitySensorChangeAction) => void): void;
+}

package/lib/interfaces/baseDevices/iAirQualityCollector.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/interfaces/baseDevices/iAirQualitySensor.d.ts

@@ -0,0 +1,97 @@
+import { iJsonOmitKeys } from '../iJsonOmitKeys';
+import { AirQualitySensorChangeAction } from '../../action';
+/**
+ * The value reported for a metric the sensor does not measure or has not reported yet.
+ */
+export declare const UNDEFINED_AIR_QUALITY_VALUE = -1;
+/**
+ * The set of air quality metrics a sensor can report.
+ *
+ * Devices differ widely in what they measure, so every member is always present but defaults to
+ * {@link UNDEFINED_AIR_QUALITY_VALUE} until the device reports it. This mirrors the sentinel approach of
+ * {@link UNDEFINED_TEMP_VALUE} and spares consumers a null check on every metric; use
+ * {@link iAirQualitySensor.reports} to tell "not measured" apart from a measured zero.
+ */
+export interface iAirQualityReadings {
+    /**
+     * The air quality index as calculated by the device (lower is better)
+     */
+    aqi: number;
+    /**
+     * The carbon dioxide concentration in ppm
+     */
+    co2: number;
+    /**
+     * The nitrogen oxide index (1 equals background level)
+     */
+    nox: number;
+    /**
+     * Particulate matter up to 1.0 µm in µg/m³
+     */
+    pm1p0: number;
+    /**
+     * Particulate matter up to 2.5 µm in µg/m³
+     */
+    pm2p5: number;
+    /**
+     * Particulate matter up to 4.0 µm in µg/m³
+     */
+    pm4p0: number;
+    /**
+     * Particulate matter up to 10.0 µm in µg/m³
+     */
+    pm10p0: number;
+    /**
+     * The total volatile organic compounds in ppb
+     */
+    tvoc: number;
+    /**
+     * The vape detection reading of the device
+     */
+    vape: number;
+    /**
+     * The volatile organic compounds index (100 equals background level)
+     */
+    voc: number;
+}
+/**
+ * Common handling for a device measuring air quality.
+ */
+export interface iAirQualitySensor extends iJsonOmitKeys {
+    /**
+     * The most recent readings of this sensor
+     */
+    readonly readings: iAirQualityReadings;
+    /**
+     * The timestamp in ms of the last received reading
+     */
+    lastSeen: number;
+    /**
+     * Applies new readings, firing the change callbacks if at least one value actually changed.
+     * @param readings - The metrics reported by the device, omitting the ones it does not measure
+     */
+    update(readings: Partial<iAirQualityReadings>): void;
+    /**
+     * Whether the device actually measures the given metric.
+     * @param metric - The metric to check
+     * @returns True if the device has reported a value for it
+     */
+    reports(metric: keyof iAirQualityReadings): boolean;
+    /**
+     * Persists the current air quality information to the database
+     */
+    persist(): void;
+    /**
+     * Adds a callback to be called when any of the readings change
+     * @param pCallback - The callback to be called
+     */
+    addAirQualityCallback(pCallback: (action: AirQualitySensorChangeAction) => void): void;
+    /**
+     * Frees up the resources of this sensor
+     */
+    dispose(): void;
+    /**
+     * @returns The serializable representation of this sensor
+     */
+    toJSON(): Partial<iAirQualitySensor>;
+}

package/lib/interfaces/baseDevices/iAirQualitySensor.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNDEFINED_AIR_QUALITY_VALUE = void 0;
+/**
+ * The value reported for a metric the sensor does not measure or has not reported yet.
+ */
+exports.UNDEFINED_AIR_QUALITY_VALUE = -1;

package/lib/interfaces/baseDevices/index.d.ts

@@ -12,6 +12,8 @@ export * from './iExcessEnergyConsumer';
 export * from './iGarageDoorOpener';
 export * from './iHandle';
 export * from './iHeater';
+export * from './iAirQualityCollector';
+export * from './iAirQualitySensor';
 export * from './iHumidityCollector';
 export * from './iIlluminationSensor';
 export * from './iLamp';

package/lib/interfaces/baseDevices/index.js

@@ -27,6 +27,8 @@ __exportStar(require("./iExcessEnergyConsumer"), exports);
 __exportStar(require("./iGarageDoorOpener"), exports);
 __exportStar(require("./iHandle"), exports);
 __exportStar(require("./iHeater"), exports);
+__exportStar(require("./iAirQualityCollector"), exports);
+__exportStar(require("./iAirQualitySensor"), exports);
 __exportStar(require("./iHumidityCollector"), exports);
 __exportStar(require("./iIlluminationSensor"), exports);
 __exportStar(require("./iLamp"), exports);

package/lib/interfaces/iPersist.d.ts

@@ -1,4 +1,4 @@
-import { iAcDevice, iActuator, iBaseDevice, iBatteryDevice, iButtonSwitch, iHandle, iHeater, iHumidityCollector, iIlluminationSensor, iMotionSensor, iShutter, iTemperatureCollector, iZigbeeDevice } from './baseDevices';
+import { iAcDevice, iActuator, iAirQualityCollector, iBaseDevice, iBatteryDevice, iButtonSwitch, iHandle, iHeater, iHumidityCollector, iIlluminationSensor, iMotionSensor, iShutter, iTemperatureCollector, iZigbeeDevice } from './baseDevices';
 import { iTemperatureMeasurement } from './iTemperatureMeasurement';
 import { iRoomBase } from './iRoomBase';
 import { ButtonPressType } from '../enums';
@@ -113,6 +113,11 @@ export interface iPersist {
      * @param device - The device to persist data for
      */
     persistHumiditySensor(device: iHumidityCollector): void;
+    /**
+     * Persists data of an air quality sensor
+     * @param device - The device to persist data for
+     */
+    persistAirQualitySensor(device: iAirQualityCollector): void;
     /**
      * Persists data of a handle sensor
      * @param device - The device to persist data for

package/lib/services/dbo/postgreSqlPersist.d.ts

@@ -1,5 +1,5 @@
 import { PoolConfig } from 'pg';
-import { iAcDevice, iActuator, iBaseDevice, iBatteryDevice, iButtonSwitch, iDesiredShutterPosition, iHandle, iHeater, iHumidityCollector, iIlluminationSensor, iMotionSensor, iPersist, iRoomBase, iShutter, iShutterCalibration, iTemperatureCollector, iTemperatureMeasurement, iZigbeeDevice } from '../../interfaces';
+import { iAcDevice, iActuator, iBaseDevice, iBatteryDevice, iButtonSwitch, iDesiredShutterPosition, iHandle, iHeater, iAirQualityCollector, iHumidityCollector, iIlluminationSensor, iMotionSensor, iPersist, iRoomBase, iShutter, iShutterCalibration, iTemperatureCollector, iTemperatureMeasurement, iZigbeeDevice } from '../../interfaces';
 import { CountToday, EnergyCalculation } from '../../models';
 import { ButtonPressType } from '../../enums';
 export declare class PostgreSqlPersist implements iPersist {
@@ -42,6 +42,8 @@ export declare class PostgreSqlPersist implements iPersist {
     /** @inheritDoc */
     persistHumiditySensor(device: iHumidityCollector): void;
     /** @inheritDoc */
+    persistAirQualitySensor(device: iAirQualityCollector): void;
+    /** @inheritDoc */
     persistBatteryDevice(device: iBatteryDevice): void;
     /** @inheritDoc */
     persistZigbeeDevice(device: iZigbeeDevice): void;