hoffmation-base 3.0.0-alpha.23 → 3.0.0-alpha.24

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

@@ -1,16 +1,64 @@
 import { DimmerSettings } from './dimmerSettings';
 export declare class WledSettings extends DimmerSettings {
+    /**
+     * @inheritDoc
+     * @default false
+     */
     dayOn: boolean;
+    /**
+     * @inheritDoc
+     * @default 100
+     */
     dayBrightness: number;
+    /**
+     * @inheritDoc
+     * @default true
+     */
     dawnOn: boolean;
+    /**
+     * @inheritDoc
+     * @default 50
+     */
     dawnBrightness: number;
+    /**
+     * @inheritDoc
+     * @default true
+     */
     duskOn: boolean;
+    /**
+     * @inheritDoc
+     * @default 50
+     */
     duskBrightness: number;
+    /**
+     * @inheritDoc
+     * @default true
+     */
     nightOn: boolean;
+    /**
+     * @inheritDoc
+     * @default 2
+     */
     nightBrightness: number;
+    /**
+     * The preset to use during the dawn
+     * @default undefined (no preset)
+     */
     dawnPreset?: number;
+    /**
+     * The preset to use during the day
+     * @default undefined (no preset)
+     */
     dayPreset?: number;
+    /**
+     * The preset to use during the dusk
+     * @default undefined (no preset)
+     */
     duskPreset?: number;
+    /**
+     * The preset to use during the night
+     * @default undefined (no preset)
+     */
     nightPreset?: number;
     fromPartialObject(data: Partial<WledSettings>): void;
     protected toJSON(): Partial<WledSettings>;

package/lib/models/deviceSettings/wledSettings.js

@@ -6,13 +6,45 @@ const server_1 = require("../../server");
 class WledSettings extends dimmerSettings_1.DimmerSettings {
     constructor() {
         super(...arguments);
+        /**
+         * @inheritDoc
+         * @default false
+         */
         this.dayOn = false;
+        /**
+         * @inheritDoc
+         * @default 100
+         */
         this.dayBrightness = 100;
+        /**
+         * @inheritDoc
+         * @default true
+         */
         this.dawnOn = true;
+        /**
+         * @inheritDoc
+         * @default 50
+         */
         this.dawnBrightness = 50;
+        /**
+         * @inheritDoc
+         * @default true
+         */
         this.duskOn = true;
+        /**
+         * @inheritDoc
+         * @default 50
+         */
         this.duskBrightness = 50;
+        /**
+         * @inheritDoc
+         * @default true
+         */
         this.nightOn = true;
+        /**
+         * @inheritDoc
+         * @default 2
+         */
         this.nightBrightness = 2;
     }
     fromPartialObject(data) {

package/lib/models/groupSettings/heatGroupSettings.d.ts

@@ -2,14 +2,23 @@ import { TemperatureSettings } from '../temperatureSettings';
 import { iIdHolder } from '../iIdHolder';
 import { GroupSettings } from './groupSettings';
 export declare class HeatGroupSettings extends GroupSettings {
+    /**
+     * The automatic points to use for the temperature calculation in automatic mode
+     */
     automaticPoints: TemperatureSettings[];
     /**
      * Whether the temperature should be calculated automatically, or the manualTemperature should be used
+     * @default true
      */
     automaticMode: boolean;
+    /**
+     * The temperature to fall back to when automaticMode is enabled and no automaticPoint is found
+     * @default 20 Degrees Celsius
+     */
     automaticFallBackTemperatur: number;
     /**
      * Target temperature when automaticMode is disabled
+     * @default 20
      */
     manualTemperature: number;
     fromPartialObject(data: Partial<HeatGroupSettings>): void;

package/lib/models/groupSettings/heatGroupSettings.js

@@ -6,14 +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
+         * @default 20
          */
         this.manualTemperature = 20;
     }

package/lib/models/iIdHolder.d.ts

@@ -1,13 +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 {LogLevel} level - The log level
-     * @param {string} message - The message to log
-     * @param {LogDebugType} logDebugType - If provided, this message will only be logged if the debug type is enabled in the settings
+     * @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

@@ -8,8 +8,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,7 @@ 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("./rooms/index"), exports);
 __exportStar(require("./deviceSettings/index"), exports);
 __exportStar(require("./persistence/index"), exports);
@@ -24,8 +25,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,5 +1,8 @@
 import { iIdHolder } from './iIdHolder';
 export declare abstract class ObjectSettings {
+    /**
+     * Callback to be fired when the settings change
+     */
     onChangeCb?: () => void;
     persist(holder: iIdHolder): void;
     /**

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;
@@ -44,6 +51,9 @@ export declare class RoomBase implements iRoomBase, iIdHolder {
     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);

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;
 }