hoffmation-base 3.0.0-alpha.8 → 3.0.0-alpha.81

package/lib/models/command/roomSetLightTimeBasedCommand.js

@@ -6,14 +6,15 @@ const commandType_1 = require("./commandType");
 class RoomSetLightTimeBasedCommand extends baseCommand_1.BaseCommand {
     /**
      * Sets the light based on the current time, rollo Position and room Settings
-     * @param source
-     * @param movementDependant Only turn light on if there was a movement in the same room
-     * @param reason
+     * @param source - The source of the command
+     * @param movementDependant - Only turn light on if there was a movement in the same room
+     * @param reason - You can provide a reason for clarity
      */
     constructor(source, movementDependant = false, reason = '') {
         super(source, reason);
         this.movementDependant = movementDependant;
-        this._commandType = commandType_1.CommandType.RoomSetLightTimeBasedCommand;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.RoomSetLightTimeBasedCommand;
     }
 }
 exports.RoomSetLightTimeBasedCommand = RoomSetLightTimeBasedCommand;

package/lib/models/command/shutterSunriseUpCommand.d.ts

@@ -2,6 +2,12 @@ import { BaseCommand } from './baseCommand';
 import { CommandSource } from './commandSource';
 import { CommandType } from './commandType';
 export declare class ShutterSunriseUpCommand extends BaseCommand {
-    _commandType: CommandType;
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Command to perform actions when the shutter should be opened due to sunrise
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source: CommandSource | BaseCommand, reason?: string);
 }

package/lib/models/command/shutterSunriseUpCommand.js

@@ -4,9 +4,15 @@ exports.ShutterSunriseUpCommand = void 0;
 const baseCommand_1 = require("./baseCommand");
 const commandType_1 = require("./commandType");
 class ShutterSunriseUpCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to perform actions when the shutter should be opened due to sunrise
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source, reason = '') {
         super(source, reason);
-        this._commandType = commandType_1.CommandType.ShutterSunriseUpCommand;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.ShutterSunriseUpCommand;
     }
 }
 exports.ShutterSunriseUpCommand = ShutterSunriseUpCommand;

package/lib/models/command/shutterSunsetDownCommand.d.ts

@@ -2,6 +2,12 @@ import { BaseCommand } from './baseCommand';
 import { CommandSource } from './commandSource';
 import { CommandType } from './commandType';
 export declare class ShutterSunsetDownCommand extends BaseCommand {
-    _commandType: CommandType;
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Command to perform actions when the shutter is closing due to sunset
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source: CommandSource | BaseCommand, reason?: string);
 }

package/lib/models/command/shutterSunsetDownCommand.js

@@ -4,9 +4,15 @@ exports.ShutterSunsetDownCommand = void 0;
 const baseCommand_1 = require("./baseCommand");
 const commandType_1 = require("./commandType");
 class ShutterSunsetDownCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to perform actions when the shutter is closing due to sunset
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source, reason = '') {
         super(source, reason);
-        this._commandType = commandType_1.CommandType.SunsetDownCommand;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.SunsetDownCommand;
     }
 }
 exports.ShutterSunsetDownCommand = ShutterSunsetDownCommand;

package/lib/models/command/wledSetLightCommand.d.ts

@@ -4,9 +4,23 @@ import { BaseCommand } from './baseCommand';
 import { DimmerSetLightCommand } from './dimmerSetLightCommand';
 import { WledSettings } from '../deviceSettings';
 import { LampSetTimeBasedCommand } from './lampSetTimeBasedCommand';
+import { BlockAutomaticCommand } from './blockAutomaticCommand';
 export declare class WledSetLightCommand extends DimmerSetLightCommand {
     preset?: number | undefined;
-    _commandType: CommandType;
-    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, timeout?: number, brightness?: number, transitionTime?: number, preset?: number | undefined);
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Command to set the light state of a WLED device
+     * @param source - The source of the command
+     * @param on - The desired state of the light
+     * @param reason - You can provide a reason for clarification
+     * @param disableAutomatic - If provided, the device will remain in the desired state for the given disable action.
+     * If undefined the default value will be used in case it's a non automatic action: {@link SettingsService.settings.blockAutomaticHandlerDefaults}
+     * @param brightness - The brightness of the light
+     * @param transitionTime - The time in milliseconds the transition should take
+     * @param preset - The preset to use
+     */
+    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, disableAutomatic?: BlockAutomaticCommand | null, brightness?: number, transitionTime?: number, preset?: number | undefined);
+    get logMessage(): string;
     static byTimeBased(settings: WledSettings, c: LampSetTimeBasedCommand): WledSetLightCommand;
 }

package/lib/models/command/wledSetLightCommand.js

@@ -5,21 +5,37 @@ const commandType_1 = require("./commandType");
 const dimmerSetLightCommand_1 = require("./dimmerSetLightCommand");
 const timeCallback_1 = require("../timeCallback");
 class WledSetLightCommand extends dimmerSetLightCommand_1.DimmerSetLightCommand {
-    constructor(source, on, reason = '', timeout = -1, brightness = -1, transitionTime = -1, preset) {
-        super(source, on, reason, timeout, brightness, transitionTime);
+    /**
+     * Command to set the light state of a WLED device
+     * @param source - The source of the command
+     * @param on - The desired state of the light
+     * @param reason - You can provide a reason for clarification
+     * @param disableAutomatic - If provided, the device will remain in the desired state for the given disable action.
+     * If undefined the default value will be used in case it's a non automatic action: {@link SettingsService.settings.blockAutomaticHandlerDefaults}
+     * @param brightness - The brightness of the light
+     * @param transitionTime - The time in milliseconds the transition should take
+     * @param preset - The preset to use
+     */
+    constructor(source, on, reason = '', disableAutomatic, brightness = -1, transitionTime = -1, preset) {
+        super(source, on, reason, disableAutomatic, brightness, transitionTime);
         this.preset = preset;
-        this._commandType = commandType_1.CommandType.WledSetLightCommand;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.WledSetLightCommand;
+    }
+    get logMessage() {
+        var _a;
+        return `Dimmer setLight to ${this.on} with Brightness ${this.brightness}, disabelAutomatic ${(_a = this.disableAutomaticCommand) === null || _a === void 0 ? void 0 : _a.logMessage} and preset ${this.preset} for reason: ${this.reasonTrace}`;
     }
     static byTimeBased(settings, c) {
         switch (c.time) {
             case timeCallback_1.TimeOfDay.Daylight:
-                return new WledSetLightCommand(c, settings.dayOn, '', c.timeout, settings.dayBrightness, undefined, settings.dayPreset);
+                return new WledSetLightCommand(c, settings.dayOn, '', c.disableAutomaticCommand, settings.dayBrightness, undefined, settings.dayPreset);
             case timeCallback_1.TimeOfDay.BeforeSunrise:
-                return new WledSetLightCommand(c, settings.dawnOn, '', c.timeout, settings.dawnBrightness, undefined, settings.dawnPreset);
+                return new WledSetLightCommand(c, settings.dawnOn, '', c.disableAutomaticCommand, settings.dawnBrightness, undefined, settings.dawnPreset);
             case timeCallback_1.TimeOfDay.AfterSunset:
-                return new WledSetLightCommand(c, settings.duskOn, '', c.timeout, settings.duskBrightness, undefined, settings.duskPreset);
+                return new WledSetLightCommand(c, settings.duskOn, '', c.disableAutomaticCommand, settings.duskBrightness, undefined, settings.duskPreset);
             case timeCallback_1.TimeOfDay.Night:
-                return new WledSetLightCommand(c, settings.nightOn, '', c.timeout, settings.nightBrightness, undefined, settings.nightPreset);
+                return new WledSetLightCommand(c, settings.nightOn, '', c.disableAutomaticCommand, settings.nightBrightness, undefined, settings.nightPreset);
             default:
                 throw new Error(`TimeOfDay ${c.time} not supported`);
         }

package/lib/models/connectionCallbacks.d.ts

@@ -1,9 +1,9 @@
 export declare class ConnectionCallbacks {
-    onAuth?: any;
-    onCommand?(pInstance: string, pCommand: string | number | boolean | any[] | Record<string, any> | null, pData: any): boolean;
+    onAuth?: unknown;
+    onCommand?(pInstance: string, pCommand: string | number | boolean | unknown[] | Record<string, unknown> | null, pData: unknown): boolean;
     onConnChange?(pState: boolean): void;
-    onError?: any;
+    onError?(error: unknown): void;
     onObjectChange?(pId: string, pObj: ioBroker.Object): void;
-    onRefresh?: any;
+    onRefresh?: unknown;
     onUpdate?(id: string, state: ioBroker.State): void;
 }

package/lib/models/connectionCallbacks.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionCallbacks = void 0;
+/* eslint-disable jsdoc/require-jsdoc */
 class ConnectionCallbacks {
 }
 exports.ConnectionCallbacks = ConnectionCallbacks;

package/lib/models/deviceConfig.d.ts

@@ -3,8 +3,8 @@ export interface deviceConfig {
     _id: string;
     ts?: number;
     from?: string;
-    native?: any;
-    common?: any & {
-        name: string;
+    native?: unknown;
+    common?: {
+        name?: string | object;
     };
 }

package/lib/models/deviceSettings/acSettings.d.ts

@@ -1,31 +1,49 @@
 import { DeviceSettings } from './deviceSettings';
 import { ExcessEnergyConsumerSettings } from '../excessEnergyConsumerSettings';
 export declare class AcSettings extends DeviceSettings {
+    /** The energy consumer settings for this AC */
     energySettings: ExcessEnergyConsumerSettings;
+    /**
+     * The earliest hour the AC can be turned on
+     */
     minimumHours: number;
+    /**
+     * The earliest minute the AC can be turned on within the hour {@link minimumHours}
+     */
     minimumMinutes: number;
+    /**
+     * The latest hour the AC can be turned on
+     */
     maximumHours: number;
+    /**
+     * The latest minute the AC can be turned on within the hour {@link maximumHours}
+     */
     maximumMinutes: number;
     /**
      * Heating can be forbidden completly e.g. for summer season
-     * @type {boolean}
      */
     heatingAllowed: boolean;
     /**
      * Whether we should ignore the room temperature and let the AC decide on its own
-     * @type {boolean}
      */
-    useOwnTemperatureAndAutomatic: boolean;
+    useOwnTemperature: boolean;
+    /**
+     * Whether the AC should use automatic mode to decide on its own whether to heat or cool
+     * @warning This can result in excessive energy consumption, as overshooting the temperature can result in the AC switching to the opposite mode
+     */
+    useAutomatic: boolean;
     /**
      * Whether we should turn off AC-Cooling when someone is in the room
-     * @type {boolean}
      */
     noCoolingOnMovement: boolean;
     /**
      * Whether this AC should be turned off for some time manually
-     * @type {boolean}
      */
     manualDisabled: boolean;
+    /**
+     * The minimum outside temperature (max. of day)  in Celsius to even consider cooling.
+     */
+    minOutdoorTempForCooling: number;
     fromPartialObject(data: Partial<AcSettings>): void;
     protected toJSON(): Partial<AcSettings>;
 }

package/lib/models/deviceSettings/acSettings.js

@@ -7,42 +7,62 @@ const excessEnergyConsumerSettings_1 = require("../excessEnergyConsumerSettings"
 class AcSettings extends deviceSettings_1.DeviceSettings {
     constructor() {
         super(...arguments);
+        /** The energy consumer settings for this AC */
         this.energySettings = new excessEnergyConsumerSettings_1.ExcessEnergyConsumerSettings();
+        /**
+         * The earliest hour the AC can be turned on
+         */
         this.minimumHours = 0;
+        /**
+         * The earliest minute the AC can be turned on within the hour {@link minimumHours}
+         */
         this.minimumMinutes = 0;
+        /**
+         * The latest hour the AC can be turned on
+         */
         this.maximumHours = 24;
+        /**
+         * The latest minute the AC can be turned on within the hour {@link maximumHours}
+         */
         this.maximumMinutes = 0;
         /**
          * Heating can be forbidden completly e.g. for summer season
-         * @type {boolean}
          */
         this.heatingAllowed = false;
         /**
          * Whether we should ignore the room temperature and let the AC decide on its own
-         * @type {boolean}
          */
-        this.useOwnTemperatureAndAutomatic = false;
+        this.useOwnTemperature = false;
+        /**
+         * Whether the AC should use automatic mode to decide on its own whether to heat or cool
+         * @warning This can result in excessive energy consumption, as overshooting the temperature can result in the AC switching to the opposite mode
+         */
+        this.useAutomatic = false;
         /**
          * Whether we should turn off AC-Cooling when someone is in the room
-         * @type {boolean}
          */
         this.noCoolingOnMovement = false;
         /**
          * Whether this AC should be turned off for some time manually
-         * @type {boolean}
          */
         this.manualDisabled = false;
+        /**
+         * The minimum outside temperature (max. of day)  in Celsius to even consider cooling.
+         */
+        this.minOutdoorTempForCooling = 21;
     }
     fromPartialObject(data) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         this.minimumHours = (_a = data.minimumHours) !== null && _a !== void 0 ? _a : this.minimumHours;
         this.minimumMinutes = (_b = data.minimumMinutes) !== null && _b !== void 0 ? _b : this.minimumMinutes;
         this.maximumHours = (_c = data.maximumHours) !== null && _c !== void 0 ? _c : this.maximumHours;
         this.maximumMinutes = (_d = data.maximumMinutes) !== null && _d !== void 0 ? _d : this.maximumMinutes;
         this.heatingAllowed = (_e = data.heatingAllowed) !== null && _e !== void 0 ? _e : this.heatingAllowed;
         this.noCoolingOnMovement = (_f = data.noCoolingOnMovement) !== null && _f !== void 0 ? _f : this.noCoolingOnMovement;
-        this.useOwnTemperatureAndAutomatic = (_g = data.useOwnTemperatureAndAutomatic) !== null && _g !== void 0 ? _g : this.useOwnTemperatureAndAutomatic;
-        this.manualDisabled = (_h = data.manualDisabled) !== null && _h !== void 0 ? _h : this.manualDisabled;
+        this.useOwnTemperature = (_g = data.useOwnTemperature) !== null && _g !== void 0 ? _g : this.useOwnTemperature;
+        this.useAutomatic = (_h = data.useAutomatic) !== null && _h !== void 0 ? _h : this.useAutomatic;
+        this.manualDisabled = (_j = data.manualDisabled) !== null && _j !== void 0 ? _j : this.manualDisabled;
+        this.minOutdoorTempForCooling = (_k = data.minOutdoorTempForCooling) !== null && _k !== void 0 ? _k : this.minOutdoorTempForCooling;
         super.fromPartialObject(data);
     }
     toJSON() {

package/lib/models/deviceSettings/actuatorSettings.d.ts

@@ -1,28 +1,37 @@
 import { DeviceSettings } from './deviceSettings';
 export declare class ActuatorSettings extends DeviceSettings {
+    /**
+     * Whether to turn on the device at dawn in time-based commands or automatic.
+     */
     dawnOn: boolean;
+    /**
+     * Whether to turn on the device at dusk in time-based commands or automatic.
+     */
     duskOn: boolean;
+    /**
+     * Whether to turn on the device at night in time-based commands or automatic.
+     */
     nightOn: boolean;
+    /**
+     * Whether to turn on the device at day in time-based commands or automatic.
+     */
+    dayOn: boolean;
     /**
      * Indicates if this device controls e.g. an Eltako, which has it's own Turn Off Time logic.
-     * @type {boolean}
      */
     isStromStoss: boolean;
     /**
      * Whether after manually turning off a previously manually turned on device, fall back to automatic mode.
      * Instead of switching to a forced off state.
-     * @type {boolean}
      */
     resetToAutomaticOnForceOffAfterForceOn: boolean;
     /**
      * If this is an Actuator controling a time based relais,
      * this indicates the time after which we retrigger the relais.
-     * @type {number}
      */
     stromStossResendTime: number;
     /**
      * Whether to include this device in the ambient light option.
-     * @type {boolean}
      */
     includeInAmbientLight: boolean;
     fromPartialObject(data: Partial<ActuatorSettings>): void;

package/lib/models/deviceSettings/actuatorSettings.js

@@ -6,42 +6,52 @@ const server_1 = require("../../server");
 class ActuatorSettings extends deviceSettings_1.DeviceSettings {
     constructor() {
         super(...arguments);
+        /**
+         * Whether to turn on the device at dawn in time-based commands or automatic.
+         */
         this.dawnOn = true;
+        /**
+         * Whether to turn on the device at dusk in time-based commands or automatic.
+         */
         this.duskOn = true;
+        /**
+         * Whether to turn on the device at night in time-based commands or automatic.
+         */
         this.nightOn = true;
+        /**
+         * Whether to turn on the device at day in time-based commands or automatic.
+         */
+        this.dayOn = false;
         /**
          * Indicates if this device controls e.g. an Eltako, which has it's own Turn Off Time logic.
-         * @type {boolean}
          */
         this.isStromStoss = false;
         /**
          * Whether after manually turning off a previously manually turned on device, fall back to automatic mode.
          * Instead of switching to a forced off state.
-         * @type {boolean}
          */
         this.resetToAutomaticOnForceOffAfterForceOn = true;
         /**
          * If this is an Actuator controling a time based relais,
          * this indicates the time after which we retrigger the relais.
-         * @type {number}
          */
         this.stromStossResendTime = 180;
         /**
          * Whether to include this device in the ambient light option.
-         * @type {boolean}
          */
         this.includeInAmbientLight = false;
     }
     fromPartialObject(data) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         this.dawnOn = (_a = data.dawnOn) !== null && _a !== void 0 ? _a : this.dawnOn;
         this.duskOn = (_b = data.duskOn) !== null && _b !== void 0 ? _b : this.duskOn;
         this.nightOn = (_c = data.nightOn) !== null && _c !== void 0 ? _c : this.nightOn;
-        this.isStromStoss = (_d = data.isStromStoss) !== null && _d !== void 0 ? _d : this.isStromStoss;
-        this.stromStossResendTime = (_e = data.stromStossResendTime) !== null && _e !== void 0 ? _e : this.stromStossResendTime;
+        this.dayOn = (_d = data.dayOn) !== null && _d !== void 0 ? _d : this.dayOn;
+        this.isStromStoss = (_e = data.isStromStoss) !== null && _e !== void 0 ? _e : this.isStromStoss;
+        this.stromStossResendTime = (_f = data.stromStossResendTime) !== null && _f !== void 0 ? _f : this.stromStossResendTime;
         this.resetToAutomaticOnForceOffAfterForceOn =
-            (_f = data.resetToAutomaticOnForceOffAfterForceOn) !== null && _f !== void 0 ? _f : this.resetToAutomaticOnForceOffAfterForceOn;
-        this.includeInAmbientLight = (_g = data.includeInAmbientLight) !== null && _g !== void 0 ? _g : this.includeInAmbientLight;
+            (_g = data.resetToAutomaticOnForceOffAfterForceOn) !== null && _g !== void 0 ? _g : this.resetToAutomaticOnForceOffAfterForceOn;
+        this.includeInAmbientLight = (_h = data.includeInAmbientLight) !== null && _h !== void 0 ? _h : this.includeInAmbientLight;
         super.fromPartialObject(data);
     }
     toJSON() {

package/lib/models/deviceSettings/cameraSettings.d.ts

@@ -1,8 +1,20 @@
 import { MotionSensorSettings } from './motionSensorSettings';
 export declare class CameraSettings extends MotionSensorSettings {
+    /**
+     * Whether to alert detected persons via telegram.
+     */
     alertPersonOnTelegram: boolean;
+    /**
+     * Whether to ignore all movement except for persons.
+     */
     movementDetectionOnPersonOnly: boolean;
+    /**
+     * Whether to also react on movement off dogs.
+     */
     movementDetectionOnDogsToo: boolean;
+    /**
+     * Whether the camera has audio.
+     */
     hasAudio: boolean;
     fromPartialObject(data: Partial<CameraSettings>): void;
     protected toJSON(): Partial<MotionSensorSettings>;

package/lib/models/deviceSettings/cameraSettings.js

@@ -6,9 +6,21 @@ const motionSensorSettings_1 = require("./motionSensorSettings");
 class CameraSettings extends motionSensorSettings_1.MotionSensorSettings {
     constructor() {
         super(...arguments);
+        /**
+         * Whether to alert detected persons via telegram.
+         */
         this.alertPersonOnTelegram = false;
+        /**
+         * Whether to ignore all movement except for persons.
+         */
         this.movementDetectionOnPersonOnly = false;
+        /**
+         * Whether to also react on movement off dogs.
+         */
         this.movementDetectionOnDogsToo = false;
+        /**
+         * Whether the camera has audio.
+         */
         this.hasAudio = false;
     }
     fromPartialObject(data) {

package/lib/models/deviceSettings/dachsSettings.d.ts

@@ -1,6 +1,29 @@
 import { ActuatorSettings } from './actuatorSettings';
 export declare class DachsDeviceSettings extends ActuatorSettings {
+    /**
+     * The refresh interval in ms to pull the data from the device.
+     */
     refreshInterval: number;
+    /**
+     * Defines the battery level at which the dachs should be turned on,
+     * to prevent a battery based island-system to be out of power.
+     * @default -1 --> No turn on for battery loading
+     *
+     * Uses {@link iBatteryDevice.addBatteryLevelCallback}
+     */
+    batteryLevelTurnOnThreshold: number;
+    /**
+     * Defines the battery level below which the dachs should be allowed to start
+     */
+    batteryLevelAllowStartThreshold: number;
+    /**
+     * Defines the battery level above which the dachs should be prevented from starting/running.
+     */
+    batteryLevelPreventStartThreshold: number;
+    /**
+     * Defines the desired minimum temperature for warm water.
+     */
+    warmWaterDesiredMinTemp: number;
     fromPartialObject(data: Partial<DachsDeviceSettings>): void;
     protected toJSON(): Partial<DachsDeviceSettings>;
 }

package/lib/models/deviceSettings/dachsSettings.js

@@ -6,11 +6,39 @@ const actuatorSettings_1 = require("./actuatorSettings");
 class DachsDeviceSettings extends actuatorSettings_1.ActuatorSettings {
     constructor() {
         super(...arguments);
+        /**
+         * The refresh interval in ms to pull the data from the device.
+         */
         this.refreshInterval = 30000;
+        /**
+         * Defines the battery level at which the dachs should be turned on,
+         * to prevent a battery based island-system to be out of power.
+         * @default -1 --> No turn on for battery loading
+         *
+         * Uses {@link iBatteryDevice.addBatteryLevelCallback}
+         */
+        this.batteryLevelTurnOnThreshold = -1;
+        /**
+         * Defines the battery level below which the dachs should be allowed to start
+         */
+        this.batteryLevelAllowStartThreshold = 50;
+        /**
+         * Defines the battery level above which the dachs should be prevented from starting/running.
+         */
+        this.batteryLevelPreventStartThreshold = 70;
+        /**
+         * Defines the desired minimum temperature for warm water.
+         */
+        this.warmWaterDesiredMinTemp = 45;
     }
     fromPartialObject(data) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         this.refreshInterval = (_a = data.refreshInterval) !== null && _a !== void 0 ? _a : this.refreshInterval;
+        this.batteryLevelTurnOnThreshold = (_b = data.batteryLevelTurnOnThreshold) !== null && _b !== void 0 ? _b : this.batteryLevelTurnOnThreshold;
+        this.batteryLevelPreventStartThreshold =
+            (_c = data.batteryLevelPreventStartThreshold) !== null && _c !== void 0 ? _c : this.batteryLevelPreventStartThreshold;
+        this.batteryLevelAllowStartThreshold = (_d = data.batteryLevelAllowStartThreshold) !== null && _d !== void 0 ? _d : this.batteryLevelAllowStartThreshold;
+        this.warmWaterDesiredMinTemp = (_e = data.warmWaterDesiredMinTemp) !== null && _e !== void 0 ? _e : this.warmWaterDesiredMinTemp;
         super.fromPartialObject(data);
     }
     toJSON() {

package/lib/models/deviceSettings/deviceSettings.d.ts

@@ -1,7 +1,17 @@
 import { ExcessEnergyConsumerSettings } from '../excessEnergyConsumerSettings';
 import { ObjectSettings } from '../objectSettings';
+import { BlockAutomaticSettings } from '../blockAutomaticSettings';
 export declare abstract class DeviceSettings extends ObjectSettings {
+    /**
+     * Any device could be an energy consumer, so we have to provide the settings for it
+     * @default undefined
+     */
     energySettings: ExcessEnergyConsumerSettings | undefined;
+    /**
+     * Any device could be an {@link iTemporaryDisableAutomatic} device, so we have to provide the settings for it
+     * @default undefined
+     */
+    blockAutomaticSettings: BlockAutomaticSettings | undefined;
     fromPartialObject(_obj: Partial<DeviceSettings>): void;
     protected toJSON(): Partial<DeviceSettings>;
 }

package/lib/models/deviceSettings/deviceSettings.js

@@ -4,10 +4,20 @@ exports.DeviceSettings = void 0;
 const excessEnergyConsumerSettings_1 = require("../excessEnergyConsumerSettings");
 const objectSettings_1 = require("../objectSettings");
 const server_1 = require("../../server");
+const blockAutomaticSettings_1 = require("../blockAutomaticSettings");
 class DeviceSettings extends objectSettings_1.ObjectSettings {
     constructor() {
         super(...arguments);
+        /**
+         * Any device could be an energy consumer, so we have to provide the settings for it
+         * @default undefined
+         */
         this.energySettings = undefined;
+        /**
+         * Any device could be an {@link iTemporaryDisableAutomatic} device, so we have to provide the settings for it
+         * @default undefined
+         */
+        this.blockAutomaticSettings = undefined;
     }
     fromPartialObject(_obj) {
         if (_obj.energySettings) {
@@ -16,6 +26,12 @@ class DeviceSettings extends objectSettings_1.ObjectSettings {
             }
             this.energySettings.fromPartialObject(_obj.energySettings);
         }
+        if (_obj.blockAutomaticSettings) {
+            if (this.blockAutomaticSettings === undefined) {
+                this.blockAutomaticSettings = new blockAutomaticSettings_1.BlockAutomaticSettings();
+            }
+            this.blockAutomaticSettings.fromPartialObject(_obj.blockAutomaticSettings);
+        }
         super.fromPartialObject(_obj);
     }
     toJSON() {

package/lib/models/deviceSettings/dimmerSettings.d.ts

@@ -1,9 +1,29 @@
 import { ActuatorSettings } from './actuatorSettings';
 export declare class DimmerSettings extends ActuatorSettings {
+    /**
+     * The desired brightness of the light during the night.
+     * @default 50
+     */
     nightBrightness: number;
+    /**
+     * The desired brightness of the light during the dawn.
+     * @default 75
+     */
     dawnBrightness: number;
+    /**
+     * The desired brightness of the light during the dusk.
+     * @default 75
+     */
     duskBrightness: number;
+    /**
+     * The desired brightness of the light during the day.
+     * @default 100
+     */
     dayBrightness: number;
+    /**
+     * Some LED dimmers have a turn on threshold, which is the minimum brightness to turn on.
+     * Hoffmation afterwards dims down the light to the desired brightness.
+     */
     turnOnThreshhold: number;
     fromPartialObject(data: Partial<DimmerSettings>): void;
     protected toJSON(): Partial<DimmerSettings>;