hoffmation-base 3.0.0-alpha.7 → 3.0.0-alpha.71

package/lib/server/devices/groups/windowGroup.d.ts

@@ -3,15 +3,30 @@ import { Window } from './Window';
 import { BaseGroup } from './base-group';
 export declare class WindowGroup extends BaseGroup {
     windows: Window[];
+    /**
+     * Timecallback for sunrise-shutter actions
+     * @remarks This callback is only set if needed and already calculated.
+     * @warning Manual setting of this callback is not recommended. Prefer {@link recalcTimeCallbacks} after changing settings.
+     */
     sunriseShutterCallback: TimeCallback | undefined;
+    /**
+     * Timecallback for sunset-shutter actions
+     * @remarks This callback is only set if needed and already calculated.
+     * @warning Manual setting of this callback is not recommended. Prefer {@link recalcTimeCallbacks} after changing settings.
+     */
     sunsetShutterCallback: TimeCallback | undefined;
+    /**
+     * Checks if any Shutter of any window is down
+     * @returns {boolean} True if there is atleast one shutte with level of 0%.
+     */
+    get anyShutterDown(): boolean;
     constructor(roomName: string, windows: Window[]);
     setDesiredPosition(c: WindowSetDesiredPositionCommand): void;
     initialize(): void;
     recalcTimeCallbacks(): void;
     setRolloByWeatherStatus(c: WindowSetRolloByWeatherStatusCommand): void;
     sunriseUp(c: ShutterSunriseUpCommand): void;
-    restoreRolloPosition(c: RoomRestoreShutterPositionCommand): void;
+    restoreShutterPosition(c: RoomRestoreShutterPositionCommand): void;
     changeVibrationMotionBlock(block: boolean): void;
     private sunsetDown;
     private reconfigureSunsetShutterCallback;

package/lib/server/devices/groups/windowGroup.js

@@ -9,6 +9,15 @@ const group_type_1 = require("./group-type");
 const device_list_1 = require("../device-list");
 const device_cluster_type_1 = require("../device-cluster-type");
 class WindowGroup extends base_group_1.BaseGroup {
+    /**
+     * Checks if any Shutter of any window is down
+     * @returns {boolean} True if there is atleast one shutte with level of 0%.
+     */
+    get anyShutterDown() {
+        return this.windows.some((w) => {
+            w.anyShutterDown;
+        });
+    }
     constructor(roomName, windows) {
         super(roomName, group_type_1.GroupType.WindowGroup);
         this.windows = windows;
@@ -62,7 +71,7 @@ class WindowGroup extends base_group_1.BaseGroup {
                 return;
             }
             if (darkOutside) {
-                f.restoreDesiredPosition(new models_1.WindowRestoreDesiredPositionCommand(c, `It's dark outside.`));
+                f.restoreDesiredPosition(new models_1.WindowRestoreDesiredPositionCommand(c, "It's dark outside."));
                 return;
             }
             let desiredPos = f.desiredPosition;
@@ -79,14 +88,14 @@ class WindowGroup extends base_group_1.BaseGroup {
         });
     }
     sunriseUp(c) {
-        this.windows.forEach((f) => {
-            if (!this.getRoom().settings.sonnenAufgangRollos || f.getShutter().length === 0) {
+        this.windows.forEach((w) => {
+            if (!this.getRoom().settings.sonnenAufgangRollos || w.getShutter().length === 0) {
                 return;
             }
-            f.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(c, 100));
+            w.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(c, 100));
         });
     }
-    restoreRolloPosition(c) {
+    restoreShutterPosition(c) {
         if (!c.recalc) {
             this.windows.forEach((f) => {
                 f.restoreDesiredPosition(new models_1.WindowRestoreDesiredPositionCommand(c));
@@ -164,7 +173,7 @@ class WindowGroup extends base_group_1.BaseGroup {
         }
         if (this.sunriseShutterCallback === undefined) {
             this.log(models_1.LogLevel.Debug, `Add Sunrise shutter TimeCallback for ${this.roomName}`);
-            this.sunriseShutterCallback = new models_1.TimeCallback(`${this.roomName} Sonnenaufgang Rollos`, models_1.TimeCallbackType.Sunrise, () => {
+            this.sunriseShutterCallback = new models_1.TimeCallback(`${this.roomName} Sunrise Shutter`, models_1.TimeCallbackType.Sunrise, () => {
                 if (room.skipNextRolloUp) {
                     this.log(models_1.LogLevel.Info, `${this.roomName} skipped sunrise up due to room.skipNextRolloUp`);
                     room.skipNextRolloUp = false;
@@ -173,7 +182,13 @@ class WindowGroup extends base_group_1.BaseGroup {
                 this.sunriseUp(new models_1.ShutterSunriseUpCommand(models_1.CommandSource.Automatic, 'Time-Callback fired'));
             }, room.settings.rolloOffset.sunrise, undefined, undefined, room.settings.rolloOffset);
             if (!services_1.TimeCallbackService.darkOutsideOrNight(services_1.TimeCallbackService.dayType(room.settings.rolloOffset))) {
-                this.sunriseUp(new models_1.ShutterSunriseUpCommand(models_1.CommandSource.Initial, 'Initial sunrise up as it is day'));
+                if (!this.anyShutterDown) {
+                    // Only set new desired position without applying it.
+                    this.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(models_1.CommandSource.Initial, 100, 'It is daytime during restart.', false));
+                }
+                else {
+                    this.sunriseUp(new models_1.ShutterSunriseUpCommand(models_1.CommandSource.Initial, 'Initial sunrise up as it is day and at least 1 shutter is down.'));
+                }
             }
             services_1.TimeCallbackService.addCallback(this.sunriseShutterCallback);
         }

package/lib/server/devices/hmIPDevices/hmIpAccessPoint.d.ts

@@ -4,6 +4,7 @@ export declare class HmIpAccessPoint extends HmIPDevice {
     constructor(pInfo: IoBrokerDeviceInfo);
     private _ip;
     get ip(): string;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     private updateBaseInformation;
 }

package/lib/server/devices/hmIPDevices/hmIpAccessPoint.js

@@ -12,6 +12,7 @@ class HmIpAccessPoint extends hmIpDevice_1.HmIPDevice {
     get ip() {
         return this._ip;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         this.log(models_1.LogLevel.DeepTrace, `AP Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         super.update(idSplit, state, initial, true);

package/lib/server/devices/hmIPDevices/hmIpBewegung.d.ts

@@ -1,26 +1,29 @@
 import { HmIPDevice } from './hmIpDevice';
-import { MotionSensorSettings } from '../../../models';
+import { MotionSensorAction, MotionSensorSettings } from '../../../models';
 import { iIlluminationSensor, iMotionSensor } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class HmIpBewegung extends HmIPDevice implements iIlluminationSensor, iMotionSensor {
     private static MOVEMENT_DETECTION;
     private static CURRENT_ILLUMINATION;
+    /** @inheritDoc */
     settings: MotionSensorSettings;
+    /** @inheritDoc */
     movementDetected: boolean;
+    /** @inheritDoc */
+    detectionsToday: number;
     private _movementDetectedCallback;
     private initialized;
     private _fallBackTimeout;
     private _lastMotionTime;
+    private _currentIllumination;
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     get timeSinceLastMotion(): number;
-    private _detectionsToday;
-    get detectionsToday(): number;
-    set detectionsToday(pVal: number);
-    private _currentIllumination;
     get currentIllumination(): number;
     private set currentIllumination(value);
-    addMovementCallback(pCallback: (pValue: boolean) => void): void;
+    addMovementCallback(pCallback: (action: MotionSensorAction) => void): void;
     persistMotionSensor(): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     updateMovement(pVal: boolean): void;
     private resetFallbackTimeout;

package/lib/server/devices/hmIPDevices/hmIpBewegung.js

@@ -10,12 +10,15 @@ class HmIpBewegung extends hmIpDevice_1.HmIPDevice {
     constructor(pInfo) {
         var _a;
         super(pInfo, deviceType_1.DeviceType.HmIpBewegung);
+        /** @inheritDoc */
         this.settings = new models_1.MotionSensorSettings();
+        /** @inheritDoc */
         this.movementDetected = false;
+        /** @inheritDoc */
+        this.detectionsToday = 0;
         this._movementDetectedCallback = [];
         this.initialized = false;
         this._lastMotionTime = 0;
-        this._detectionsToday = 0;
         this._currentIllumination = -1;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.motionSensor);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.illuminationSensor);
@@ -33,15 +36,10 @@ class HmIpBewegung extends hmIpDevice_1.HmIPDevice {
             });
         }
     }
+    /** @inheritDoc */
     get timeSinceLastMotion() {
         return Math.floor((services_1.Utils.nowMS() - this._lastMotionTime) / 1000);
     }
-    get detectionsToday() {
-        return this._detectionsToday;
-    }
-    set detectionsToday(pVal) {
-        this._detectionsToday = pVal;
-    }
     get currentIllumination() {
         return this._currentIllumination;
     }
@@ -57,6 +55,7 @@ class HmIpBewegung extends hmIpDevice_1.HmIPDevice {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistMotionSensor(this);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         this.log(models_1.LogLevel.DeepTrace, `Bewegungs Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
         super.update(idSplit, state, initial, true);
@@ -75,7 +74,7 @@ class HmIpBewegung extends hmIpDevice_1.HmIPDevice {
     }
     updateMovement(pVal) {
         if (!this.initialized && pVal) {
-            this.log(models_1.LogLevel.Trace, `Bewegung erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern`);
+            this.log(models_1.LogLevel.Trace, 'Bewegung erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern');
             services_1.Utils.guardedTimeout(() => {
                 this.updateMovement(pVal);
             }, 1000, this);
@@ -100,18 +99,18 @@ class HmIpBewegung extends hmIpDevice_1.HmIPDevice {
             this.log(models_1.LogLevel.Trace, `Dies ist die ${this.detectionsToday} Bewegung `);
         }
         for (const c of this._movementDetectedCallback) {
-            c(pVal);
+            c(new models_1.MotionSensorAction(this));
         }
     }
     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);
         }
     }
     startFallbackTimeout() {
         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);

package/lib/server/devices/hmIPDevices/hmIpDevice.d.ts

@@ -2,8 +2,7 @@ import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
 import { DeviceType } from '../deviceType';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class HmIPDevice extends IoBrokerBaseDevice {
-    lowBattery: boolean;
-    stateMap: Map<string, ioBroker.State>;
     constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
 }

package/lib/server/devices/hmIPDevices/hmIpDevice.js

@@ -6,9 +6,8 @@ const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
 class HmIPDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     constructor(pInfo, pType) {
         super(pInfo, pType);
-        this.lowBattery = false;
-        this.stateMap = new Map();
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false, pOverride = false) {
         if (!pOverride) {
             this.log(models_1.LogLevel.Trace, `Keine Update Überschreibung :\n\tID: ${idSplit.join('.')}`);
@@ -20,7 +19,7 @@ class HmIPDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
             case '0.LOW_BAT':
                 const newBatLowVal = state.val;
                 if (newBatLowVal) {
-                    this.log(models_1.LogLevel.Warn, `!!BATTERIE FAST LEER!!`);
+                    this.log(models_1.LogLevel.Warn, '!!BATTERIE FAST LEER!!');
                 }
                 break;
         }

package/lib/server/devices/hmIPDevices/hmIpGriff.d.ts

@@ -1,35 +1,66 @@
 import { iDisposable } from '../../services';
 import { WindowPosition } from '../models';
 import { Window } from '../groups';
+import { BatteryLevelChangeAction } from '../../../models';
 import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { HmIPDevice } from './hmIpDevice';
 import { iBatteryDevice, iHandleSensor } from '../baseDeviceInterfaces';
 import { HandleSettings } from '../../../models/deviceSettings/handleSettings';
 export declare class HmIpGriff extends HmIPDevice implements iHandleSensor, iBatteryDevice, iDisposable {
+    /** @inheritDoc */
     settings: HandleSettings;
+    /** @inheritDoc */
+    position: WindowPosition;
+    /** @inheritDoc */
+    minutesOpen: number;
     private _battery;
     private _lastBatteryPersist;
     private _lastHandlePersist;
-    get lastBatteryPersist(): number;
-    get battery(): number;
-    position: WindowPosition;
     private _kippCallback;
     private _closedCallback;
     private _offenCallback;
     private _iOpenTimeout;
-    minutesOpen: number;
     private _window;
     private _helpingRoomTemp;
+    private _lastBatteryLevel;
+    private _batteryLevelCallbacks;
+    /**
+     * Creates an instance of {@link DeviceType.HmIpGriff}.
+     * @param pInfo - Device creation information
+     */
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get lastBatteryPersist(): number;
+    /** @inheritDoc */
+    get battery(): number;
+    /**
+     * Adds a window to this device
+     */
     set window(value: Window);
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    /** @inheritDoc */
     addOffenCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
     addKippCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
     addClosedCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    updatePosition(pValue: WindowPosition): void;
+    /** @inheritDoc */
     persistBatteryDevice(): void;
+    /**
+     * Persists the handle sensor state to the persistence layer
+     */
     persistHandleSensor(): void;
+    /** @inheritDoc */
     dispose(): void;
+    /** @inheritDoc */
     toJSON(): Partial<IoBrokerBaseDevice>;
+    private updatePosition;
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    private checkForBatteryChange;
 }

package/lib/server/devices/hmIPDevices/hmIpGriff.js

@@ -13,40 +13,62 @@ const hmIpDevice_1 = require("./hmIpDevice");
 const DeviceCapability_1 = require("../DeviceCapability");
 const handleSettings_1 = require("../../../models/deviceSettings/handleSettings");
 class HmIpGriff extends hmIpDevice_1.HmIPDevice {
-    get lastBatteryPersist() {
-        return this._lastBatteryPersist;
-    }
-    get battery() {
-        return this._battery;
-    }
+    /**
+     * Creates an instance of {@link DeviceType.HmIpGriff}.
+     * @param pInfo - Device creation information
+     */
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.HmIpGriff);
+        /** @inheritDoc */
         this.settings = new handleSettings_1.HandleSettings();
+        /** @inheritDoc */
+        this.position = models_1.WindowPosition.geschlossen;
+        /** @inheritDoc */
+        this.minutesOpen = 0;
         this._battery = -99;
         this._lastBatteryPersist = 0;
         this._lastHandlePersist = 0;
-        this.position = models_1.WindowPosition.geschlossen;
         this._kippCallback = [];
         this._closedCallback = [];
         this._offenCallback = [];
-        this.minutesOpen = 0;
         this._window = undefined;
         this._helpingRoomTemp = false;
+        this._lastBatteryLevel = -1;
+        this._batteryLevelCallbacks = [];
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.handleSensor);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
     }
+    /** @inheritDoc */
+    get lastBatteryPersist() {
+        return this._lastBatteryPersist;
+    }
+    /** @inheritDoc */
+    get battery() {
+        return this._battery;
+    }
+    /**
+     * Adds a window to this device
+     */
     set window(value) {
         this._window = value;
     }
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback) {
+        this._batteryLevelCallbacks.push(pCallback);
+    }
+    /** @inheritDoc */
     addOffenCallback(pCallback) {
         this._offenCallback.push(pCallback);
     }
+    /** @inheritDoc */
     addKippCallback(pCallback) {
         this._kippCallback.push(pCallback);
     }
+    /** @inheritDoc */
     addClosedCallback(pCallback) {
         this._closedCallback.push(pCallback);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         this.log(models_2.LogLevel.DeepTrace, `Griff Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
         super.update(idSplit, state, initial, true);
@@ -55,6 +77,7 @@ class HmIpGriff extends hmIpDevice_1.HmIPDevice {
                 switch (idSplit[4]) {
                     case 'OPERATING_VOLTAGE':
                         this._battery = 100 * ((state.val - 0.9) / 0.6);
+                        this.checkForBatteryChange();
                         this.persistBatteryDevice();
                         break;
                 }
@@ -66,12 +89,47 @@ class HmIpGriff extends hmIpDevice_1.HmIPDevice {
                         break;
                     case 'OPERATING_VOLTAGE':
                         this._battery = 100 * ((state.val - 0.9) / 0.6);
+                        this.checkForBatteryChange();
                         this.persistBatteryDevice();
                         break;
                 }
                 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;
+    }
+    /**
+     * Persists the handle sensor state to the persistence layer
+     */
+    persistHandleSensor() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastHandlePersist + 2000 > now) {
+            return;
+        }
+        this.log(models_2.LogLevel.Debug, `Persist handle state: ${this.position}`);
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHandleSensor(this);
+        this._lastHandlePersist = now;
+    }
+    /** @inheritDoc */
+    dispose() {
+        if (this._iOpenTimeout) {
+            clearInterval(this._iOpenTimeout);
+            this._iOpenTimeout = undefined;
+        }
+    }
+    /** @inheritDoc */
+    toJSON() {
+        return lodash_1.default.omit(super.toJSON(), ['_window']);
+    }
     updatePosition(pValue) {
         if (pValue === this.position) {
             if (this._lastHandlePersist == 0) {
@@ -116,7 +174,7 @@ class HmIpGriff extends hmIpDevice_1.HmIPDevice {
                     const wouldHelp = (desiredTemp < currentTemp && outSideTemp < currentTemp) ||
                         (desiredTemp > currentTemp && outSideTemp > currentTemp);
                     if (!wouldHelp && this._helpingRoomTemp) {
-                        const info = `Window should be closed, as it doesn't help reaching target temperature.`;
+                        const info = "Window should be closed, as it doesn't help reaching target temperature.";
                         this.log(models_2.LogLevel.Info, info);
                         if (this.settings.informNotHelping) {
                             services_1.TelegramService.inform(info);
@@ -155,33 +213,18 @@ class HmIpGriff extends hmIpDevice_1.HmIPDevice {
             }
         }, 60000, 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;
-    }
-    persistHandleSensor() {
-        var _a;
-        const now = services_1.Utils.nowMS();
-        if (this._lastHandlePersist + 2000 > now) {
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    checkForBatteryChange() {
+        const newLevel = this.battery;
+        if (newLevel == -1 || newLevel == this._lastBatteryLevel) {
             return;
         }
-        this.log(models_2.LogLevel.Debug, `Persist handle state: ${this.position}`);
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHandleSensor(this);
-        this._lastHandlePersist = now;
-    }
-    dispose() {
-        if (this._iOpenTimeout) {
-            clearInterval(this._iOpenTimeout);
-            this._iOpenTimeout = undefined;
+        for (const cb of this._batteryLevelCallbacks) {
+            cb(new models_2.BatteryLevelChangeAction(this));
         }
-    }
-    toJSON() {
-        return lodash_1.default.omit(super.toJSON(), ['_window']);
+        this._lastBatteryLevel = newLevel;
     }
 }
 exports.HmIpGriff = HmIpGriff;

package/lib/server/devices/hmIPDevices/hmIpHeizgruppe.d.ts

@@ -1,13 +1,17 @@
 /// <reference types="node" />
 import { HmIPDevice } from './hmIpDevice';
 import { iDisposable } from '../../services';
-import { HeaterSettings } from '../../../models';
+import { HeaterSettings, HumiditySensorChangeAction, TemperatureSensorChangeAction } from '../../../models';
 import { iHeater, iHumiditySensor, iTemperatureSensor } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class HmIpHeizgruppe extends HmIPDevice implements iTemperatureSensor, iHumiditySensor, iHeater, iDisposable {
+    /** @inheritDoc */
     readonly persistHeaterInterval: NodeJS.Timeout;
+    /** @inheritDoc */
     readonly persistTemperatureSensorInterval: NodeJS.Timeout;
+    /** @inheritDoc */
     readonly persistHumiditySensorInterval: NodeJS.Timeout;
+    /** @inheritDoc */
     settings: HeaterSettings;
     private _iAutomaticInterval;
     private _initialSeasonCheckDone;
@@ -17,35 +21,51 @@ export declare class HmIpHeizgruppe extends HmIPDevice implements iTemperatureSe
     private _temperatureCallbacks;
     constructor(pInfo: IoBrokerDeviceInfo);
     protected _seasonTurnOff: boolean;
+    /** @inheritDoc */
     get seasonTurnOff(): boolean;
+    /** @inheritDoc */
     set seasonTurnOff(value: boolean);
     private _temperature;
     get temperature(): number;
     private set temperature(value);
     private _humidity;
+    /** @inheritDoc */
     get humidity(): number;
     private set humidity(value);
     private _desiredTemperature;
+    /** @inheritDoc */
     get desiredTemperature(): number;
+    /** @inheritDoc */
     set desiredTemperature(val: number);
     get sLevel(): string;
+    /** @inheritDoc */
     get iLevel(): number;
+    /** @inheritDoc */
     get sTemperature(): string;
+    /** @inheritDoc */
     get iTemperature(): number;
     private _roomTemperature;
+    /** @inheritDoc */
     get roomTemperature(): number;
-    set roomTemperature(value: number);
-    addHumidityCallback(pCallback: (pValue: number) => void): void;
+    /** @inheritDoc */
+    addHumidityCallback(pCallback: (action: HumiditySensorChangeAction) => void): void;
     getBelongingHeizungen(): iHeater[];
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    stopAutomaticCheck(): void;
+    /** @inheritDoc */
     checkAutomaticChange(): void;
-    addTempChangeCallback(pCallback: (pValue: number) => void): void;
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback: (action: TemperatureSensorChangeAction) => void): void;
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
     persistTemperaturSensor(): void;
+    /** @inheritDoc */
     persistHeater(): void;
+    /** @inheritDoc */
     persistHumiditySensor(): void;
     private updateBaseInformation;
     private checkSeasonTurnOff;
+    /** @inheritDoc */
     dispose(): void;
 }