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

package/lib/models/groupSettings/heatGroupSettings.js

@@ -6,12 +6,23 @@ const groupSettings_1 = require("./groupSettings");
 class HeatGroupSettings extends groupSettings_1.GroupSettings {
     constructor() {
         super(...arguments);
+        /**
+         * The automatic points to use for the temperature calculation in automatic mode
+         */
         this.automaticPoints = [];
+        /**
+         * Whether the temperature should be calculated automatically, or the manualTemperature should be used
+         * @default true
+         */
         this.automaticMode = true;
+        /**
+         * The temperature to fall back to when automaticMode is enabled and no automaticPoint is found
+         * @default 20 Degrees Celsius
+         */
         this.automaticFallBackTemperatur = 20;
         /**
          * Target temperature when automaticMode is disabled
-         * @type {number}
+         * @default 20
          */
         this.manualTemperature = 20;
     }

package/lib/models/iIdHolder.d.ts

@@ -1,7 +1,25 @@
 import { LogLevel } from './logLevel';
 import { LogDebugType } from '../server';
+/**
+ * Interface for objects that have an unique id and a custom name
+ * The id can be used for API interaction, storing settings to the database, etc.
+ */
 export interface iIdHolder {
+    /**
+     * The id of the object.
+     * @warning This should be unique across all objects
+     */
     readonly id: string;
+    /**
+     * The custom name of the object --> This can be a duplicate to other objects
+     * This should be the human-readable name of the object.
+     */
     readonly customName: string;
+    /**
+     * Logs a message for this idHolder
+     * @param level - The log level
+     * @param message - The message to log
+     * @param logDebugType - If provided, this message will only be logged if the debug type is enabled in the settings
+     */
     log(level: LogLevel, message: string, logDebugType?: LogDebugType): void;
 }

package/lib/models/index.d.ts

@@ -1,3 +1,4 @@
+export * from './action/index';
 export * from './rooms/index';
 export * from './deviceSettings/index';
 export * from './persistence/index';
@@ -8,8 +9,8 @@ export * from './command';
 export * from './daytime';
 export * from './deviceConfig';
 export * from './excessEnergyConsumerSettings';
-export * from './iTemperaturDataPoint';
 export * from './logLevel';
 export * from './objectSettings';
 export * from './temperatureSettings';
 export * from './timeCallback';
+export { BlockAutomaticSettings } from './blockAutomaticSettings';

package/lib/models/index.js

@@ -14,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAutomaticSettings = void 0;
+__exportStar(require("./action/index"), exports);
 __exportStar(require("./rooms/index"), exports);
 __exportStar(require("./deviceSettings/index"), exports);
 __exportStar(require("./persistence/index"), exports);
@@ -24,8 +26,9 @@ __exportStar(require("./command"), exports);
 __exportStar(require("./daytime"), exports);
 __exportStar(require("./deviceConfig"), exports);
 __exportStar(require("./excessEnergyConsumerSettings"), exports);
-__exportStar(require("./iTemperaturDataPoint"), exports);
 __exportStar(require("./logLevel"), exports);
 __exportStar(require("./objectSettings"), exports);
 __exportStar(require("./temperatureSettings"), exports);
 __exportStar(require("./timeCallback"), exports);
+var blockAutomaticSettings_1 = require("./blockAutomaticSettings");
+Object.defineProperty(exports, "BlockAutomaticSettings", { enumerable: true, get: function () { return blockAutomaticSettings_1.BlockAutomaticSettings; } });

package/lib/models/objectSettings.d.ts

@@ -1,11 +1,14 @@
 import { iIdHolder } from './iIdHolder';
 export declare abstract class ObjectSettings {
+    /**
+     * Callback to be fired when the settings change
+     */
     onChangeCb?: () => void;
     persist(holder: iIdHolder): void;
     /**
      * Loads the settings from the database
-     * @param {iIdHolder} holder The holder of the settings (e.g. a device)
-     * @param {() => void} loadDoneCb Callback when loading is done
+     * @param holder - The holder of the settings (e.g. a device)
+     * @param loadDoneCb - Callback when loading is done
      */
     initializeFromDb(holder: iIdHolder, loadDoneCb?: () => void): void;
     fromPartialObject(_obj: Partial<ObjectSettings>): void;

package/lib/models/objectSettings.js

@@ -14,8 +14,8 @@ class ObjectSettings {
     }
     /**
      * Loads the settings from the database
-     * @param {iIdHolder} holder The holder of the settings (e.g. a device)
-     * @param {() => void} loadDoneCb Callback when loading is done
+     * @param holder - The holder of the settings (e.g. a device)
+     * @param loadDoneCb - Callback when loading is done
      */
     initializeFromDb(holder, loadDoneCb) {
         var _a;

package/lib/models/persistence/EnergyCalculation.d.ts

@@ -2,14 +2,41 @@ import { LogLevel } from '../logLevel';
 import { LogDebugType } from '../../server';
 export declare class EnergyCalculation {
     startMs: number;
+    /**
+     * The amount of energy drawn from the grid in kWh since the last calculation
+     */
     drawnKwH: number;
+    /**
+     * The amount of energy injected into the grid in kWh since the last calculation
+     */
     injectedKwH: number;
+    /**
+     * The amount of energy self consumed in kWh since the last calculation
+     */
     selfConsumedKwH: number;
+    /**
+     * The cost of the energy drawn from the grid since the last calculation
+     */
     costDrawn: number;
+    /**
+     * The money earned by injecting energy into the grid since the last calculation
+     */
     earnedInjected: number;
+    /**
+     * The amount of money saved by self consuming energy since the last calculation
+     */
     savedSelfConsume: number;
+    /**
+     * The timestamp of the end of this calculation
+     */
     endMs: number;
+    /**
+     * The amount of energy stored in the battery in kWh since the last calculation
+     */
     batteryStoredKwH: number;
+    /**
+     * Current battery level in %
+     */
     batteryLevel: number;
     constructor(startMs: number);
     static persist(obj: EnergyCalculation, endMs: number, logger: (level: LogLevel, message: string, logDebugType?: LogDebugType) => void): boolean;

package/lib/models/persistence/EnergyCalculation.js

@@ -6,25 +6,51 @@ const server_1 = require("../../server");
 class EnergyCalculation {
     constructor(startMs) {
         this.startMs = startMs;
+        /**
+         * The amount of energy drawn from the grid in kWh since the last calculation
+         */
         this.drawnKwH = 0;
+        /**
+         * The amount of energy injected into the grid in kWh since the last calculation
+         */
         this.injectedKwH = 0;
+        /**
+         * The amount of energy self consumed in kWh since the last calculation
+         */
         this.selfConsumedKwH = 0;
+        /**
+         * The cost of the energy drawn from the grid since the last calculation
+         */
         this.costDrawn = 0;
+        /**
+         * The money earned by injecting energy into the grid since the last calculation
+         */
         this.earnedInjected = 0;
+        /**
+         * The amount of money saved by self consuming energy since the last calculation
+         */
         this.savedSelfConsume = 0;
+        /**
+         * The timestamp of the end of this calculation
+         */
         this.endMs = 0;
+        /**
+         * The amount of energy stored in the battery in kWh since the last calculation
+         */
         this.batteryStoredKwH = 0;
-        // Battery Level in %
+        /**
+         * Current battery level in %
+         */
         this.batteryLevel = 0.0;
     }
     static persist(obj, endMs, logger) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         if (obj.drawnKwH === 0 && obj.injectedKwH === 0 && obj.selfConsumedKwH === 0) {
-            logger(logLevel_1.LogLevel.Warn, `Not persisting energy Data, as all values are 0.`);
+            logger(logLevel_1.LogLevel.Warn, 'Not persisting energy Data, as all values are 0.');
             return false;
         }
         if (!((_a = server_1.SettingsService.settings.energyManager) === null || _a === void 0 ? void 0 : _a.wattagePrice)) {
-            logger(logLevel_1.LogLevel.Warn, `Wattage price not set, assuming average of 34ct.`);
+            logger(logLevel_1.LogLevel.Warn, 'Wattage price not set, assuming average of 34ct.');
         }
         obj.endMs = endMs;
         obj.earnedInjected = server_1.Utils.round(obj.injectedKwH * ((_c = (_b = server_1.SettingsService.settings.energyManager) === null || _b === void 0 ? void 0 : _b.injectWattagePrice) !== null && _c !== void 0 ? _c : 0.06), 4);
@@ -36,7 +62,7 @@ class EnergyCalculation {
         obj.batteryStoredKwH = server_1.Utils.round(obj.batteryStoredKwH, 3);
         obj.batteryLevel = server_1.Utils.round(obj.batteryLevel, 3);
         (_h = server_1.Utils.dbo) === null || _h === void 0 ? void 0 : _h.persistEnergyManager(obj);
-        logger(logLevel_1.LogLevel.Info, `Persisting energy Manager Data.`);
+        logger(logLevel_1.LogLevel.Info, 'Persisting energy Manager Data.');
         return true;
     }
 }

package/lib/models/persistence/index.d.ts

@@ -2,7 +2,5 @@ export * from './BasicRoomInfo';
 export * from './DesiredShutterPosition';
 export * from './EnergyCalculation';
 export * from './idSettings';
-export * from './RoomDetailInfo';
 export * from './ShutterCalibration';
-export * from './temperaturDataPoint';
 export * from './todaysCount';

package/lib/models/persistence/index.js

@@ -18,7 +18,5 @@ __exportStar(require("./BasicRoomInfo"), exports);
 __exportStar(require("./DesiredShutterPosition"), exports);
 __exportStar(require("./EnergyCalculation"), exports);
 __exportStar(require("./idSettings"), exports);
-__exportStar(require("./RoomDetailInfo"), exports);
 __exportStar(require("./ShutterCalibration"), exports);
-__exportStar(require("./temperaturDataPoint"), exports);
 __exportStar(require("./todaysCount"), exports);

package/lib/models/rooms/RoomBase.d.ts

@@ -8,8 +8,15 @@ import { iIdHolder } from '../iIdHolder';
 import { RoomSetLightTimeBasedCommand } from '../command';
 export declare class RoomBase implements iRoomBase, iIdHolder {
     groupMap: Map<GroupType, BaseGroup>;
+    /**
+     * @see RoomInfo
+     */
     info: RoomInfo;
+    /** @inheritDoc */
     skipNextRolloUp: boolean;
+    /**
+     * The settings for this room
+     */
     settings: RoomSettingsController;
     constructor(groupMap: Map<GroupType, BaseGroup>, roomName: string, etage?: number, startPoint?: TrilaterationPoint, endPoint?: TrilaterationPoint);
     get sonnenUntergangLichtCallback(): TimeCallback | undefined;
@@ -18,7 +25,7 @@ export declare class RoomBase implements iRoomBase, iIdHolder {
     get sunsetShutterCallback(): TimeCallback | undefined;
     /**
      * For Rooms the id is itss name
-     * @returns {string} The Roomname
+     * @returns The Roomname
      */
     get id(): string;
     get customName(): string;
@@ -39,10 +46,14 @@ export declare class RoomBase implements iRoomBase, iIdHolder {
     recalcTimeCallbacks(): void;
     /**
      * Sets the light based on the current time, rollo Position and room Settings
+     * @param c - The command to execute
      */
     setLightTimeBased(c: RoomSetLightTimeBasedCommand): void;
     isNowLightTime(): boolean;
     toJSON(): Partial<RoomBase & {
+        /**
+         * The dictionary representation of the group map
+         */
         groupDict?: {
             [p: string]: BaseGroup;
         };

package/lib/models/rooms/RoomBase.js

@@ -14,6 +14,7 @@ const command_1 = require("../command");
 class RoomBase {
     constructor(groupMap, roomName, etage = 99, startPoint, endPoint) {
         this.groupMap = groupMap;
+        /** @inheritDoc */
         this.skipNextRolloUp = false;
         this._deviceCluster = new server_1.DeviceCluster();
         this.info = new roomInfo_1.RoomInfo(roomName, etage);
@@ -41,7 +42,7 @@ class RoomBase {
     }
     /**
      * For Rooms the id is itss name
-     * @returns {string} The Roomname
+     * @returns The Roomname
      */
     get id() {
         return this.roomName;
@@ -106,6 +107,7 @@ class RoomBase {
     }
     /**
      * Sets the light based on the current time, rollo Position and room Settings
+     * @param c - The command to execute
      */
     setLightTimeBased(c) {
         var _a, _b;
@@ -115,7 +117,7 @@ class RoomBase {
         }
         if (c.movementDependant && this.PraesenzGroup && !((_a = this.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.anyPresent())) {
             this.log(logLevel_1.LogLevel.Trace, 'Turn off lights as no-one is present.');
-            this.LightGroup.switchAll(new command_1.ActuatorSetStateCommand(c, false, 'Room.setLightTimeBased but no one is present'));
+            this.LightGroup.switchAll(new command_1.ActuatorSetStateCommand(c, false, 'No one is present --> Turn off lights.'));
             return;
         }
         if (!this.settings.lampOffset && !this.settings.roomIsAlwaysDark) {
@@ -132,7 +134,7 @@ class RoomBase {
                 })))) {
             timeOfDay = server_1.Utils.nowTime().hours > 16 ? timeCallback_1.TimeOfDay.AfterSunset : timeCallback_1.TimeOfDay.BeforeSunrise;
         }
-        this.LightGroup.switchTimeConditional(new command_1.LightGroupSwitchTimeConditionalCommand(c, timeOfDay, 'Roombase.setLightTimeBased'));
+        this.LightGroup.switchTimeConditional(new command_1.LightGroupSwitchTimeConditionalCommand(c, timeOfDay));
     }
     isNowLightTime() {
         var _a;

package/lib/models/rooms/RoomSettings/RoomInitializationSettings.d.ts

@@ -2,7 +2,8 @@ import { iRoomInitializationSettings } from './iRoomInitializationSettings';
 import { RoomDeviceAddingSettings } from './roomDeviceAddingSettings';
 export declare class RoomInitializationSettings implements iRoomInitializationSettings {
     shortName: string;
-    deviceAddidngSettings?: RoomDeviceAddingSettings;
+    /** @inheritDoc */
+    deviceAddingSettings?: RoomDeviceAddingSettings;
     constructor(shortName: string);
     static registerRoomForDevices(roomInitializationSettings: RoomInitializationSettings): void;
 }

package/lib/models/rooms/RoomSettings/RoomInitializationSettings.js

@@ -7,8 +7,8 @@ class RoomInitializationSettings {
         this.shortName = shortName;
     }
     static registerRoomForDevices(roomInitializationSettings) {
-        if (roomInitializationSettings.deviceAddidngSettings !== undefined) {
-            server_1.IoBrokerBaseDevice.addRoom(roomInitializationSettings.shortName, roomInitializationSettings.deviceAddidngSettings);
+        if (roomInitializationSettings.deviceAddingSettings !== undefined) {
+            server_1.IoBrokerBaseDevice.addRoom(roomInitializationSettings.shortName, roomInitializationSettings.deviceAddingSettings);
         }
     }
 }

package/lib/models/rooms/RoomSettings/RoomSettingsController.d.ts

@@ -4,8 +4,17 @@ import { iTimePair, SunTimeOffsets } from '../../../server';
 import { RoomSettings } from './roomSettings';
 export declare class RoomSettingsController implements iRoomDefaultSettings {
     constructor(room: RoomBase);
+    /**
+     * The name of the room this settings are for
+     */
     roomName: string;
+    /**
+     * The offset used for shutter sunrise/sunset actions
+     */
     rolloOffset: SunTimeOffsets;
+    /**
+     * The offset used for lamp sunrise/sunset actions
+     */
     lampOffset: SunTimeOffsets;
     private _settingsContainer;
     get settingsContainer(): RoomSettings;

package/lib/models/rooms/RoomSettings/RoomSettingsController.js

@@ -88,7 +88,7 @@ class RoomSettingsController {
     }
     toJSON() {
         const result = server_1.Utils.jsonFilter(this);
-        return lodash_1.default.omit(result, [`defaultSettings`, 'deviceAddidngSettings']);
+        return lodash_1.default.omit(result, ['defaultSettings', 'deviceAddidngSettings']);
     }
     onSettingChange() {
         server_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `${this.roomName} RoomSettingsController.onSettingChange`);

package/lib/models/rooms/RoomSettings/iRoomDefaultSettings.d.ts

@@ -1,28 +1,78 @@
 import { iTimePair } from '../../../server';
+/**
+ * Default settings for a room, which can then be overwritten by the room settings for each specific room
+ */
 export interface iRoomDefaultSettings {
     /**
-     * The default radio URL to use with speaker
+     * @see RoomSettings.radioUrl
      */
     readonly radioUrl?: string;
+    /**
+     * @see RoomSettings.rolloHeatReduction
+     */
     readonly rolloHeatReduction: boolean;
     /**
-     * Indicates rooms, which are time independent always dark (like basement).
-     * This results in lamps beeing turned on on motion regardless of windows and time.
+     * @see RoomSettings.roomIsAlwaysDark
      */
     readonly roomIsAlwaysDark: boolean;
+    /**
+     * @see RoomSettings.lampenBeiBewegung
+     */
     readonly lampenBeiBewegung: boolean;
+    /**
+     * @see RoomSettings.lichtSonnenAufgangAus
+     */
     readonly lichtSonnenAufgangAus: boolean;
+    /**
+     * @see RoomSettings.sonnenUntergangRollos
+     */
     readonly sonnenUntergangRollos: boolean;
+    /**
+     * @see RoomSettings.sonnenUntergangRolloDelay
+     */
     readonly sonnenUntergangRolloDelay: number;
+    /**
+     * @see RoomSettings.sonnenUntergangRolloMaxTime
+     */
     readonly sonnenUntergangRolloMaxTime: iTimePair;
+    /**
+     * @see RoomSettings.sonnenUntergangLampenDelay
+     */
     readonly sonnenUntergangLampenDelay: number;
+    /**
+     * @see RoomSettings.sonnenUntergangRolloAdditionalOffsetPerCloudiness
+     */
     readonly sonnenUntergangRolloAdditionalOffsetPerCloudiness: number;
+    /**
+     * @see RoomSettings.sonnenUntergangRollos
+     */
     readonly sonnenAufgangRollos: boolean;
+    /**
+     * @see RoomSettings.sonnenAufgangRolloDelay
+     */
     readonly sonnenAufgangRolloDelay: number;
+    /**
+     * @see RoomSettings.sonnenAufgangRolloMinTime
+     */
     readonly sonnenAufgangRolloMinTime: iTimePair;
+    /**
+     * @see RoomSettings.sonnenAufgangLampenDelay
+     */
     readonly sonnenAufgangLampenDelay: number;
+    /**
+     * @see RoomSettings.movementResetTimer
+     */
     readonly movementResetTimer: number;
+    /**
+     * @see RoomSettings.lightIfNoWindows
+     */
     readonly lightIfNoWindows: boolean;
+    /**
+     * @see RoomSettings.ambientLightAfterSunset
+     */
     readonly ambientLightAfterSunset: boolean;
+    /**
+     * @see RoomSettings.includeLampsInNormalMovementLightning
+     */
     readonly includeLampsInNormalMovementLightning: boolean;
 }

package/lib/models/rooms/RoomSettings/iRoomInitializationSettings.d.ts

@@ -1,5 +1,14 @@
 import { RoomDeviceAddingSettings } from './roomDeviceAddingSettings';
+/**
+ * The settings for initializing a room (after Devices are generated) to add devices to the room
+ */
 export interface iRoomInitializationSettings {
-    deviceAddidngSettings?: RoomDeviceAddingSettings;
+    /**
+     * The settings for adding a device to the room
+     */
+    deviceAddingSettings?: RoomDeviceAddingSettings;
+    /**
+     * The short name of the room
+     */
     shortName: string;
 }

package/lib/models/rooms/RoomSettings/roomDeviceAddingSettings.d.ts

@@ -3,7 +3,10 @@ import { RoomAddDeviceItem } from './roomAddDeviceItem';
 import { RoomBase } from '../RoomBase';
 export declare class RoomDeviceAddingSettings {
     RoomName: string;
-    devices: Array<Array<RoomAddDeviceItem>>;
+    /**
+     * The devices that are to be added to the room
+     */
+    devices: RoomAddDeviceItem[][];
     constructor(RoomName: string);
     addDevice(deviceType: DeviceType, setID: (value: string) => RoomBase, index: number, customName?: string | undefined): void;
     checkMissing(): void;

package/lib/models/rooms/RoomSettings/roomDeviceAddingSettings.js

@@ -7,6 +7,9 @@ const logLevel_1 = require("../../logLevel");
 class RoomDeviceAddingSettings {
     constructor(RoomName) {
         this.RoomName = RoomName;
+        /**
+         * The devices that are to be added to the room
+         */
         this.devices = [];
     }
     addDevice(deviceType, setID, index, customName = undefined) {

package/lib/models/rooms/RoomSettings/roomSettings.d.ts

@@ -1,23 +1,78 @@
 import { ObjectSettings } from '../../objectSettings';
 import { iTimePair } from '../../../server';
 export declare class RoomSettings extends ObjectSettings {
+    /**
+     * Whether this room should always have ambient light on after sunset (regardless of motion e.g. Gardenlights).
+     */
     ambientLightAfterSunset: boolean;
+    /**
+     * Should lights be turned off after sunrise
+     */
     lichtSonnenAufgangAus: boolean;
+    /**
+     * The default radio URL to use with speaker
+     */
     radioUrl: string;
+    /**
+     * Use shutter to reduce warming of rooms on hot days (detected by weather service)
+     */
     rolloHeatReduction: boolean;
+    /**
+     * Should lights be turned on at Movement
+     */
     lampenBeiBewegung: boolean;
+    /**
+     * Should Light be turned on at day if there are no Windows configured for this room
+     */
     lightIfNoWindows: boolean;
+    /**
+     * Time in seconds after which detected movement is reseted
+     */
     movementResetTimer: number;
+    /**
+     * Indicates rooms, which are time independent always dark (like basement).
+     * This results in lamps beeing turned on at motion regardless of windows and time.
+     */
     roomIsAlwaysDark: boolean;
+    /**
+     * +/- Offset for still turning on lamps at movement after/before sunrise
+     */
     sonnenAufgangLampenDelay: number;
+    /**
+     * +/- Default Offset for shutters opening on sunrise in minutes
+     */
     sonnenAufgangRolloDelay: number;
+    /**
+     * Should shutters be opened on sunrise
+     */
     sonnenAufgangRollos: boolean;
+    /**
+     * !Needs Weather Data! Additional Offset in Minutes per % Cloudiness
+     */
     sonnenUntergangRolloAdditionalOffsetPerCloudiness: number;
+    /**
+     * Latest time of shutter closing (regardless of geospecific sunset)
+     */
     sonnenUntergangRolloMaxTime: iTimePair;
+    /**
+     * Earliest time of shutter opening (regardless of geospecific sunset)
+     */
     sonnenAufgangRolloMinTime: iTimePair;
+    /**
+     * +/- Offset for shutter closing on sunset in minutes
+     */
     sonnenUntergangRolloDelay: number;
+    /**
+     * +/- Offset for turning on lamps at movement after/before sunset
+     */
     sonnenUntergangLampenDelay: number;
+    /**
+     * Should shutters be closed on sunset (based on geolocation)
+     */
     sonnenUntergangRollos: boolean;
+    /**
+     * Whether normal ceiling lights should also be turned on by movement, even if there are LEDs and outlets
+     */
     includeLampsInNormalMovementLightning: boolean;
     fromPartialObject(_obj: Partial<RoomSettings>): void;
 }

package/lib/models/rooms/RoomSettings/roomSettings.js

@@ -7,23 +7,78 @@ class RoomSettings extends objectSettings_1.ObjectSettings {
     constructor() {
         var _a;
         super(...arguments);
+        /**
+         * Whether this room should always have ambient light on after sunset (regardless of motion e.g. Gardenlights).
+         */
         this.ambientLightAfterSunset = server_1.SettingsService.settings.roomDefault.ambientLightAfterSunset;
+        /**
+         * Should lights be turned off after sunrise
+         */
         this.lichtSonnenAufgangAus = server_1.SettingsService.settings.roomDefault.lichtSonnenAufgangAus;
+        /**
+         * The default radio URL to use with speaker
+         */
         this.radioUrl = (_a = server_1.SettingsService.settings.roomDefault.radioUrl) !== null && _a !== void 0 ? _a : '';
+        /**
+         * Use shutter to reduce warming of rooms on hot days (detected by weather service)
+         */
         this.rolloHeatReduction = server_1.SettingsService.settings.roomDefault.rolloHeatReduction;
+        /**
+         * Should lights be turned on at Movement
+         */
         this.lampenBeiBewegung = server_1.SettingsService.settings.roomDefault.lampenBeiBewegung;
+        /**
+         * Should Light be turned on at day if there are no Windows configured for this room
+         */
         this.lightIfNoWindows = server_1.SettingsService.settings.roomDefault.lightIfNoWindows;
+        /**
+         * Time in seconds after which detected movement is reseted
+         */
         this.movementResetTimer = server_1.SettingsService.settings.roomDefault.movementResetTimer;
+        /**
+         * Indicates rooms, which are time independent always dark (like basement).
+         * This results in lamps beeing turned on at motion regardless of windows and time.
+         */
         this.roomIsAlwaysDark = server_1.SettingsService.settings.roomDefault.roomIsAlwaysDark;
+        /**
+         * +/- Offset for still turning on lamps at movement after/before sunrise
+         */
         this.sonnenAufgangLampenDelay = server_1.SettingsService.settings.roomDefault.sonnenAufgangLampenDelay;
+        /**
+         * +/- Default Offset for shutters opening on sunrise in minutes
+         */
         this.sonnenAufgangRolloDelay = server_1.SettingsService.settings.roomDefault.sonnenAufgangRolloDelay;
+        /**
+         * Should shutters be opened on sunrise
+         */
         this.sonnenAufgangRollos = server_1.SettingsService.settings.roomDefault.sonnenAufgangRollos;
+        /**
+         * !Needs Weather Data! Additional Offset in Minutes per % Cloudiness
+         */
         this.sonnenUntergangRolloAdditionalOffsetPerCloudiness = server_1.SettingsService.settings.roomDefault.sonnenUntergangRolloAdditionalOffsetPerCloudiness;
+        /**
+         * Latest time of shutter closing (regardless of geospecific sunset)
+         */
         this.sonnenUntergangRolloMaxTime = server_1.SettingsService.settings.roomDefault.sonnenUntergangRolloMaxTime;
+        /**
+         * Earliest time of shutter opening (regardless of geospecific sunset)
+         */
         this.sonnenAufgangRolloMinTime = server_1.SettingsService.settings.roomDefault.sonnenAufgangRolloMinTime;
+        /**
+         * +/- Offset for shutter closing on sunset in minutes
+         */
         this.sonnenUntergangRolloDelay = server_1.SettingsService.settings.roomDefault.sonnenUntergangRolloDelay;
+        /**
+         * +/- Offset for turning on lamps at movement after/before sunset
+         */
         this.sonnenUntergangLampenDelay = server_1.SettingsService.settings.roomDefault.sonnenUntergangLampenDelay;
+        /**
+         * Should shutters be closed on sunset (based on geolocation)
+         */
         this.sonnenUntergangRollos = server_1.SettingsService.settings.roomDefault.sonnenUntergangRollos;
+        /**
+         * Whether normal ceiling lights should also be turned on by movement, even if there are LEDs and outlets
+         */
         this.includeLampsInNormalMovementLightning = server_1.SettingsService.settings.roomDefault.includeLampsInNormalMovementLightning;
     }
     fromPartialObject(_obj) {