hoffmation-base 3.0.0-alpha.3 → 3.0.0-alpha.31

package/lib/server/devices/zigbee/BaseDevices/zigbeeHeater.js

@@ -8,9 +8,11 @@ const services_1 = require("../../../services");
 const DeviceCapability_1 = require("../../DeviceCapability");
 const liquid_pid_1 = require("../../../../liquid-pid");
 class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
+    /** @inheritDoc */
     get lastBatteryPersist() {
         return this._lastBatteryPersist;
     }
+    /** @inheritDoc */
     get battery() {
         return this._battery;
     }
@@ -18,9 +20,11 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         super(pInfo, pType);
         this._battery = -99;
         this._lastBatteryPersist = 0;
+        /** @inheritDoc */
         this.persistHeaterInterval = services_1.Utils.guardedInterval(() => {
             this.persistHeater();
         }, 5 * 60 * 1000, this, false);
+        /** @inheritDoc */
         this.settings = new models_1.HeaterSettings();
         this._initialSeasonCheckDone = false;
         this._level = 0;
@@ -38,7 +42,6 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
             Kd: 9, // PID: Kd in 1/1000
         });
         this._seasonTurnOff = false;
-        this._humidity = 0;
         this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.heater);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
@@ -47,15 +50,19 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
             this.checkSeasonTurnOff();
         }, 0, 2, 0));
     }
+    /** @inheritDoc */
     get seasonTurnOff() {
         return this._seasonTurnOff;
     }
+    /** @inheritDoc */
     set seasonTurnOff(value) {
         this._seasonTurnOff = value;
     }
+    /** @inheritDoc */
     get desiredTemperature() {
         return this._desiredTemperatur;
     }
+    /** @inheritDoc */
     set desiredTemperature(val) {
         this._desiredTemperatur = val;
         this.setState(this._setPointTemperaturID, val, () => {
@@ -64,18 +71,17 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
             this.log(models_1.LogLevel.Error, `Temperaturänderung ergab Fehler ${err}.`);
         });
     }
-    get humidity() {
-        return this._humidity;
-    }
     get sLevel() {
         return `${this._level * 100}%`;
     }
+    /** @inheritDoc */
     get iLevel() {
         return this._level;
     }
     get sTemperatur() {
         return `${this.iTemperature}°C`;
     }
+    /** @inheritDoc */
     get iTemperature() {
         if (this.settings.useOwnTemperatur) {
             return this._temperatur;
@@ -84,12 +90,14 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
             return this._roomTemperature;
         }
     }
+    /** @inheritDoc */
     get roomTemperature() {
         return this._roomTemperature;
     }
     set roomTemperatur(val) {
         this._roomTemperature = val;
     }
+    /** @inheritDoc */
     checkAutomaticChange() {
         var _a;
         if (!this._initialSeasonCheckDone) {
@@ -113,12 +121,7 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
             this.desiredTemperature = targetTemperature;
         }
     }
-    stopAutomaticCheck() {
-        if (this._iAutomaticInterval !== undefined) {
-            clearInterval(this._iAutomaticInterval);
-            this._iAutomaticInterval = undefined;
-        }
-    }
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur) {
         this.roomTemperatur = newTemperatur;
     }
@@ -126,13 +129,14 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHeater(this);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false, pOverride = false) {
         switch (idSplit[3]) {
             case 'battery':
                 this._battery = state.val;
                 this.persistBatteryDevice();
                 if (this._battery < 20) {
-                    this.log(models_1.LogLevel.Warn, `Das Zigbee Gerät hat unter 20% Batterie.`);
+                    this.log(models_1.LogLevel.Warn, 'Das Zigbee Gerät hat unter 20% Batterie.');
                 }
                 break;
         }
@@ -155,6 +159,7 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         }
         this._initialSeasonCheckDone = true;
     }
+    /** @inheritDoc */
     persistBatteryDevice() {
         var _a;
         const now = services_1.Utils.nowMS();
@@ -164,6 +169,7 @@ class ZigbeeHeater extends zigbeeDevice_1.ZigbeeDevice {
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
         this._lastBatteryPersist = now;
     }
+    /** @inheritDoc */
     dispose() {
         if (this.persistHeaterInterval) {
             clearInterval(this.persistHeaterInterval);

package/lib/server/devices/zigbee/BaseDevices/zigbeeLamp.d.ts

@@ -0,0 +1,20 @@
+import { ZigbeeActuator } from './ZigbeeActuator';
+import { iLamp, iTemporaryDisableAutomatic } from '../../baseDeviceInterfaces';
+import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../../models';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { DeviceType } from '../../deviceType';
+export declare abstract class ZigbeeLamp extends ZigbeeActuator implements iLamp, iTemporaryDisableAutomatic {
+    protected abstract readonly _stateNameState: string;
+    protected _lightOn: boolean;
+    constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    /** @inheritDoc */
+    get lightOn(): boolean;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    /** @inheritDoc */
+    setTimeBased(c: LampSetTimeBasedCommand): void;
+    /** @inheritdoc */
+    setLight(c: LampSetLightCommand): void;
+    /** @inheritDoc */
+    toggleLight(c: LampToggleLightCommand): boolean;
+}

package/lib/server/devices/zigbee/BaseDevices/zigbeeLamp.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeLamp = void 0;
+const ZigbeeActuator_1 = require("./ZigbeeActuator");
+const models_1 = require("../../../../models");
+const sharedFunctions_1 = require("../../sharedFunctions");
+const DeviceCapability_1 = require("../../DeviceCapability");
+class ZigbeeLamp extends ZigbeeActuator_1.ZigbeeActuator {
+    constructor(pInfo, deviceType) {
+        super(pInfo, deviceType);
+        this._lightOn = false;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.lamp);
+    }
+    /** @inheritDoc */
+    get lightOn() {
+        return this._lightOn;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, handledByChildObject = false) {
+        if (!handledByChildObject) {
+            this.log(models_1.LogLevel.DeepTrace, `Aktuator Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        }
+        this.queuedValue = null;
+        this.log(models_1.LogLevel.DeepTrace, `Dimmer Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case this._stateNameState:
+                this.log(models_1.LogLevel.Trace, `Lamp Update für ${this.info.customName} auf ${state.val}`);
+                this._lightOn = state.val;
+                this.persist();
+                break;
+        }
+    }
+    /** @inheritDoc */
+    setTimeBased(c) {
+        sharedFunctions_1.LampUtils.setTimeBased(this, c);
+    }
+    /** @inheritdoc */
+    setLight(c) {
+        super.setActuator(c);
+    }
+    /** @inheritDoc */
+    toggleLight(c) {
+        return sharedFunctions_1.LampUtils.toggleLight(this, c);
+    }
+}
+exports.ZigbeeLamp = ZigbeeLamp;

package/lib/server/devices/zigbee/BaseDevices/zigbeeLedRGBCCT.d.ts

@@ -1,10 +1,10 @@
 import { DeviceType } from '../../deviceType';
-import { LampSetTimeBasedCommand, LedSetLightCommand, LedSettings } from '../../../../models';
+import { ActuatorSetStateCommand, LampSetTimeBasedCommand, LedSetLightCommand, LedSettings } from '../../../../models';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
 import { iLedRgbCct } from '../../baseDeviceInterfaces/iLedRgbCct';
 import { ZigbeeDimmer } from './zigbeeDimmer';
 export declare abstract class ZigbeeLedRGBCCT extends ZigbeeDimmer implements iLedRgbCct {
-    static DEFAULT_COLOR_WARM: string;
+    /** @inheritDoc */
     settings: LedSettings;
     protected abstract readonly _stateIdColor: string;
     protected abstract readonly _stateIdColorTemp: string;
@@ -12,16 +12,17 @@ export declare abstract class ZigbeeLedRGBCCT extends ZigbeeDimmer implements iL
     protected abstract readonly _stateNameColorTemp: string;
     protected constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
     protected _color: string;
+    /** @inheritDoc */
     get color(): string;
     protected _colortemp: number;
+    /** @inheritDoc */
     get colortemp(): number;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     setTimeBased(c: LampSetTimeBasedCommand): void;
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
+    setActuator(c: ActuatorSetStateCommand): void;
+    /** @inheritDoc */
     setLight(c: LedSetLightCommand): void;
 }

package/lib/server/devices/zigbee/BaseDevices/zigbeeLedRGBCCT.js

@@ -8,19 +8,23 @@ const services_1 = require("../../../services");
 class ZigbeeLedRGBCCT extends zigbeeDimmer_1.ZigbeeDimmer {
     constructor(pInfo, deviceType) {
         super(pInfo, deviceType);
+        /** @inheritDoc */
         this.settings = new models_1.LedSettings();
         this._color = '#fcba32';
         this._colortemp = 500;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.ledLamp);
         // this.effectID = `${this.info.fullID}.effect`;
     }
+    /** @inheritDoc */
     get color() {
         return this._color;
     }
+    /** @inheritDoc */
     get colortemp() {
         return this._colortemp;
     }
     // private effectID: string = '';
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         this.log(models_1.LogLevel.DeepTrace, `LED Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         super.update(idSplit, state, initial);
@@ -35,37 +39,35 @@ class ZigbeeLedRGBCCT extends zigbeeDimmer_1.ZigbeeDimmer {
                 break;
         }
     }
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     setTimeBased(c) {
         this.setLight(models_1.LedSetLightCommand.byTimeBased(this.settings, c));
     }
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
+    setActuator(c) {
+        this.setLight(new models_1.LedSetLightCommand(c, c.on, '', c.disableAutomaticCommand));
+    }
+    /** @inheritDoc */
     setLight(c) {
         if (this._stateIdState === '') {
-            this.log(models_1.LogLevel.Error, `Keine State ID bekannt.`);
+            this.log(models_1.LogLevel.Error, 'Keine State ID bekannt.');
             return;
         }
         if (!this.ioConn) {
-            this.log(models_1.LogLevel.Error, `Keine Connection bekannt.`);
+            this.log(models_1.LogLevel.Error, 'Keine Connection bekannt.');
             return;
         }
         if (c.on && c.brightness === -1 && this.brightness < 10) {
             c.brightness = 10;
         }
-        this.log(models_1.LogLevel.Debug, `LED Schalten An: ${c.on}\tHelligkeit: ${c.brightness}%\tFarbe: "${c.color}"\tColorTemperatur: ${c.colorTemp}\tTransition Time: ${c.transitionTime}`);
+        super.setLight(c);
         const formattedColor = services_1.Utils.formatHex(c.color);
-        if (formattedColor !== null && c.on) {
+        if (formattedColor !== null && c.on && (c.color !== this.color || c.isForceAction)) {
             this.setState(this._stateIdColor, formattedColor);
         }
-        if (c.colorTemp > -1 && c.on) {
+        if (c.colorTemp > -1 && c.on && (c.colorTemp !== this.colortemp || c.isForceAction)) {
             this.setState(this._stateIdColorTemp, c.colorTemp);
         }
-        super.setLight(c);
     }
 }
 exports.ZigbeeLedRGBCCT = ZigbeeLedRGBCCT;
-ZigbeeLedRGBCCT.DEFAULT_COLOR_WARM = '#f2b200';

package/lib/server/devices/zigbee/BaseDevices/zigbeeMagnetContact.d.ts

@@ -2,24 +2,34 @@ import { DeviceType } from '../../deviceType';
 import { ZigbeeDevice } from './zigbeeDevice';
 import { MagnetPosition } from '../../models';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
-import { iBatteryDevice } from '../../baseDeviceInterfaces';
-export declare class ZigbeeMagnetContact extends ZigbeeDevice implements iBatteryDevice {
+import { iBatteryDevice, iMagnetSensor } from '../../baseDeviceInterfaces';
+export declare class ZigbeeMagnetContact extends ZigbeeDevice implements iBatteryDevice, iMagnetSensor {
     protected _battery: number;
     private _lastBatteryPersist;
+    /** @inheritDoc */
     get lastBatteryPersist(): number;
+    /** @inheritDoc */
     get battery(): number;
+    /** @inheritDoc */
     position: MagnetPosition;
+    /** @inheritDoc */
     telegramOnOpen: boolean;
+    /** @inheritDoc */
     speakOnOpen: boolean;
     private _closedCallback;
     private _openCallback;
     private _iOpenTimeout;
     private minutesOpen;
     constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    /** @inheritDoc */
     addOpenCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
     addClosedCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverrride?: boolean): void;
     protected updatePosition(pValue: MagnetPosition): void;
+    /** @inheritDoc */
     dispose(): void;
+    /** @inheritDoc */
     persistBatteryDevice(): void;
 }

package/lib/server/devices/zigbee/BaseDevices/zigbeeMagnetContact.js

@@ -6,9 +6,11 @@ const models_1 = require("../../../../models");
 const zigbeeDevice_1 = require("./zigbeeDevice");
 const models_2 = require("../../models");
 class ZigbeeMagnetContact extends zigbeeDevice_1.ZigbeeDevice {
+    /** @inheritDoc */
     get lastBatteryPersist() {
         return this._lastBatteryPersist;
     }
+    /** @inheritDoc */
     get battery() {
         return this._battery;
     }
@@ -16,19 +18,25 @@ class ZigbeeMagnetContact extends zigbeeDevice_1.ZigbeeDevice {
         super(pInfo, deviceType);
         this._battery = -99;
         this._lastBatteryPersist = 0;
+        /** @inheritDoc */
         this.position = models_2.MagnetPosition.closed;
+        /** @inheritDoc */
         this.telegramOnOpen = false;
+        /** @inheritDoc */
         this.speakOnOpen = false;
         this._closedCallback = [];
         this._openCallback = [];
         this.minutesOpen = 0;
     }
+    /** @inheritDoc */
     addOpenCallback(pCallback) {
         this._openCallback.push(pCallback);
     }
+    /** @inheritDoc */
     addClosedCallback(pCallback) {
         this._closedCallback.push(pCallback);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false, pOverrride = false) {
         super.update(idSplit, state, initial, pOverrride);
         switch (idSplit[3]) {
@@ -36,7 +44,7 @@ class ZigbeeMagnetContact extends zigbeeDevice_1.ZigbeeDevice {
                 this._battery = state.val;
                 this.persistBatteryDevice();
                 if (this._battery < 20) {
-                    this.log(models_1.LogLevel.Warn, `Das Zigbee Gerät hat unter 20% Batterie.`);
+                    this.log(models_1.LogLevel.Warn, 'Das Zigbee Gerät hat unter 20% Batterie.');
                 }
                 break;
         }
@@ -98,6 +106,7 @@ class ZigbeeMagnetContact extends zigbeeDevice_1.ZigbeeDevice {
             }, 60000, this);
         }
     }
+    /** @inheritDoc */
     dispose() {
         if (this._iOpenTimeout) {
             clearInterval(this._iOpenTimeout);
@@ -105,6 +114,7 @@ class ZigbeeMagnetContact extends zigbeeDevice_1.ZigbeeDevice {
         }
         super.dispose();
     }
+    /** @inheritDoc */
     persistBatteryDevice() {
         var _a;
         const now = services_1.Utils.nowMS();

package/lib/server/devices/zigbee/BaseDevices/zigbeeMotionSensor.d.ts

@@ -4,33 +4,42 @@ import { ZigbeeDevice } from './index';
 import { MotionSensorSettings } from '../../../../models';
 import { iBatteryDevice, iMotionSensor } from '../../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { MotionSensorAction } from '../../../../models/action/motionSensorAction';
 export declare class ZigbeeMotionSensor extends ZigbeeDevice implements iMotionSensor, iBatteryDevice {
+    /** @inheritDoc */
+    settings: MotionSensorSettings;
+    /** @inheritDoc */
+    detectionsToday: number;
+    protected _initialized: boolean;
+    protected _movementDetectedCallback: Array<(action: MotionSensorAction) => void>;
+    protected _needsMovementResetFallback: boolean;
+    protected _fallBackTimeout: NodeJS.Timeout | undefined;
+    protected _timeSinceLastMotion: number;
     private _movementDetected;
     private _battery;
     private _lastBatteryPersist;
+    constructor(pInfo: IoBrokerDeviceInfo, type: DeviceType);
+    /** @inheritDoc */
     get lastBatteryPersist(): number;
-    settings: MotionSensorSettings;
+    /** @inheritDoc */
     get movementDetected(): boolean;
+    /** @inheritDoc */
     get battery(): number;
-    protected _initialized: boolean;
-    protected _movementDetectedCallback: Array<(pValue: boolean) => void>;
-    protected _needsMovementResetFallback: boolean;
-    protected _fallBackTimeout: NodeJS.Timeout | undefined;
-    constructor(pInfo: IoBrokerDeviceInfo, type: DeviceType);
-    protected _timeSinceLastMotion: number;
+    /** @inheritDoc */
     get timeSinceLastMotion(): number;
-    protected _detectionsToday: number;
-    get detectionsToday(): number;
-    set detectionsToday(pVal: number);
     /**
      * Adds a callback for when a motion state has changed.
-     * @param pCallback Function that accepts the new state as parameter
+     * @param pCallback - Function that accepts the new state as parameter
      */
-    addMovementCallback(pCallback: (newState: boolean) => void): void;
+    /** @inheritDoc */
+    addMovementCallback(pCallback: (action: MotionSensorAction) => void): void;
+    /** @inheritDoc */
     persistMotionSensor(): void;
     updateMovement(newState: boolean): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
+    persistBatteryDevice(): void;
     private resetFallbackTimeout;
     private startFallbackTimeout;
-    persistBatteryDevice(): void;
 }

package/lib/server/devices/zigbee/BaseDevices/zigbeeMotionSensor.js

@@ -5,36 +5,22 @@ const index_1 = require("./index");
 const models_1 = require("../../../../models");
 const services_1 = require("../../../services");
 const DeviceCapability_1 = require("../../DeviceCapability");
+const motionSensorAction_1 = require("../../../../models/action/motionSensorAction");
 class ZigbeeMotionSensor extends index_1.ZigbeeDevice {
-    get lastBatteryPersist() {
-        return this._lastBatteryPersist;
-    }
-    get movementDetected() {
-        if (!this.available) {
-            // If the device is not available, there is no active movement
-            return false;
-        }
-        if (services_1.Utils.nowMS() - this.lastUpdate.getTime() > 3600000) {
-            // If the device has not been updated for more than an hour, there is no active movement
-            return false;
-        }
-        return this._movementDetected;
-    }
-    get battery() {
-        return this._battery;
-    }
     constructor(pInfo, type) {
         var _a;
         super(pInfo, type);
-        this._movementDetected = false;
-        this._battery = -99;
-        this._lastBatteryPersist = 0;
+        /** @inheritDoc */
         this.settings = new models_1.MotionSensorSettings();
+        /** @inheritDoc */
+        this.detectionsToday = 0;
         this._initialized = false;
         this._movementDetectedCallback = [];
         this._needsMovementResetFallback = true;
         this._timeSinceLastMotion = 0;
-        this._detectionsToday = 0;
+        this._movementDetected = false;
+        this._battery = -99;
+        this._lastBatteryPersist = 0;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.motionSensor);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
         if (!services_1.Utils.anyDboActive) {
@@ -52,30 +38,47 @@ class ZigbeeMotionSensor extends index_1.ZigbeeDevice {
             });
         }
     }
+    /** @inheritDoc */
+    get lastBatteryPersist() {
+        return this._lastBatteryPersist;
+    }
+    /** @inheritDoc */
+    get movementDetected() {
+        if (!this.available) {
+            // If the device is not available, there is no active movement
+            return false;
+        }
+        if (services_1.Utils.nowMS() - this.lastUpdate.getTime() > 3600000) {
+            // If the device has not been updated for more than an hour, there is no active movement
+            return false;
+        }
+        return this._movementDetected;
+    }
+    /** @inheritDoc */
+    get battery() {
+        return this._battery;
+    }
     // Time since last motion in seconds
+    /** @inheritDoc */
     get timeSinceLastMotion() {
         return this._timeSinceLastMotion;
     }
-    get detectionsToday() {
-        return this._detectionsToday;
-    }
-    set detectionsToday(pVal) {
-        this._detectionsToday = pVal;
-    }
     /**
      * Adds a callback for when a motion state has changed.
-     * @param pCallback Function that accepts the new state as parameter
+     * @param pCallback - Function that accepts the new state as parameter
      */
+    /** @inheritDoc */
     addMovementCallback(pCallback) {
         this._movementDetectedCallback.push(pCallback);
     }
+    /** @inheritDoc */
     persistMotionSensor() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistMotionSensor(this);
     }
     updateMovement(newState) {
         if (!this._initialized && newState) {
-            this.log(models_1.LogLevel.Trace, `Movement recognized, but database initialization has not finished yet --> delay.`);
+            this.log(models_1.LogLevel.Trace, 'Movement recognized, but database initialization has not finished yet --> delay.');
             services_1.Utils.guardedTimeout(() => {
                 this.updateMovement(newState);
             }, 1000, this);
@@ -100,9 +103,10 @@ class ZigbeeMotionSensor extends index_1.ZigbeeDevice {
             this.log(models_1.LogLevel.Trace, `This is movement no. ${this.detectionsToday}`);
         }
         for (const c of this._movementDetectedCallback) {
-            c(newState);
+            c(new motionSensorAction_1.MotionSensorAction(this));
         }
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false, pOverride = false) {
         this.log(models_1.LogLevel.DeepTrace, `Motion update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         super.update(idSplit, state, initial, pOverride);
@@ -111,7 +115,7 @@ class ZigbeeMotionSensor extends index_1.ZigbeeDevice {
                 this._battery = state.val;
                 this.persistBatteryDevice();
                 if (this._battery < 20) {
-                    this.log(models_1.LogLevel.Warn, `Das Zigbee Gerät hat unter 20% Batterie.`);
+                    this.log(models_1.LogLevel.Warn, 'Das Zigbee Gerät hat unter 20% Batterie.');
                 }
                 break;
             case 'occupancy':
@@ -124,9 +128,19 @@ class ZigbeeMotionSensor extends index_1.ZigbeeDevice {
                 break;
         }
     }
+    /** @inheritDoc */
+    persistBatteryDevice() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastBatteryPersist + 60000 > now) {
+            return;
+        }
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
+        this._lastBatteryPersist = now;
+    }
     resetFallbackTimeout() {
         if (this._fallBackTimeout) {
-            this.log(models_1.LogLevel.Trace, `Fallback Timeout zurücksetzen`);
+            this.log(models_1.LogLevel.Trace, 'Fallback Timeout zurücksetzen');
             clearTimeout(this._fallBackTimeout);
         }
     }
@@ -135,19 +149,10 @@ class ZigbeeMotionSensor extends index_1.ZigbeeDevice {
             return;
         }
         this._fallBackTimeout = services_1.Utils.guardedTimeout(() => {
-            this.log(models_1.LogLevel.Debug, `Benötige Fallback Bewegungs Reset`);
+            this.log(models_1.LogLevel.Debug, 'Benötige Fallback Bewegungs Reset');
             this._fallBackTimeout = undefined;
             this.updateMovement(false);
         }, 270000, this);
     }
-    persistBatteryDevice() {
-        var _a;
-        const now = services_1.Utils.nowMS();
-        if (this._lastBatteryPersist + 60000 > now) {
-            return;
-        }
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
-        this._lastBatteryPersist = now;
-    }
 }
 exports.ZigbeeMotionSensor = ZigbeeMotionSensor;

package/lib/server/devices/zigbee/BaseDevices/zigbeeShutter.d.ts

@@ -7,6 +7,7 @@ import { Window } from '../../groups';
 import { IoBrokerBaseDevice } from '../../IoBrokerBaseDevice';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
 export declare class ZigbeeShutter extends ZigbeeDevice implements iShutter {
+    /** @inheritDoc */
     settings: ShutterSettings;
     protected _iMovementFinishTimeout: NodeJS.Timeout | null;
     protected _firstCommandRecieved: boolean;
@@ -15,15 +16,24 @@ export declare class ZigbeeShutter extends ZigbeeDevice implements iShutter {
     protected _shutterCalibrationData: ShutterCalibration;
     constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
     protected _currentLevel: number;
+    /** @inheritDoc */
     get currentLevel(): number;
-    set currentLevel(value: number);
+    /** @inheritDoc */
+    protected set currentLevel(value: number);
     protected _window?: Window;
+    /** @inheritDoc */
     get window(): Window | undefined;
+    /** @inheritDoc */
     set window(value: Window | undefined);
+    /** @inheritDoc */
     get desiredWindowShutterLevel(): number;
+    /** @inheritDoc */
     persist(): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
     setLevel(c: ShutterSetLevelCommand): void;
+    /** @inheritDoc */
     toJSON(): Partial<IoBrokerBaseDevice>;
     protected moveToPosition(pPosition: number): void;
     protected getAverageUp(): number;