hoffmation-base 3.0.2 → 3.1.0

package/lib/devices/dachs/dachs.js

@@ -0,0 +1,378 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dachs = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const action_1 = require("../../action");
+const settingsObjects_1 = require("../../settingsObjects");
+const enums_1 = require("../../enums");
+const dachsTemperatureSensor_1 = require("./dachsTemperatureSensor");
+const lib_1 = require("./lib");
+const DeviceInfo_1 = require("../DeviceInfo");
+const devices_1 = require("../devices");
+const utils_1 = require("../../utils");
+const api_1 = require("../../api");
+const logging_1 = require("../../logging");
+const sharedFunctions_1 = require("../sharedFunctions");
+const sun_time_offsets_1 = require("../../models/sun-time-offsets");
+const command_1 = require("../../command");
+const services_1 = require("../../services");
+const settings_service_1 = require("../../settings-service");
+class Dachs {
+    /** @inheritDoc */
+    get customName() {
+        return this.info.customName;
+    }
+    /** @inheritDoc */
+    get actuatorOn() {
+        return this._dachsOn;
+    }
+    constructor(options) {
+        var _a, _b;
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.DachsDeviceSettings();
+        /** @inheritDoc */
+        this.deviceType = enums_1.DeviceType.Dachs;
+        /** @inheritDoc */
+        this.deviceCapabilities = [];
+        /** @inheritDoc */
+        this.queuedValue = null;
+        /** @inheritDoc */
+        this.targetAutomaticState = false;
+        this._dachsOn = false;
+        this._tempWarmWater = 0;
+        this._tempHeatStorage = 0;
+        this.deviceCapabilities.push(enums_1.DeviceCapability.actuator);
+        this._info = new DeviceInfo_1.DeviceInfo();
+        this._info.fullName = 'Dachs';
+        this._info.customName = `Dachs ${options.roomName}`;
+        this._info.allDevicesKey = `dachs-${options.roomName}`;
+        this._info.room = options.roomName;
+        devices_1.Devices.alLDevices[this._info.allDevicesKey] = this;
+        if (options.influxDb) {
+            this._influxClient = new lib_1.DachsInfluxClient(options.influxDb);
+        }
+        this.persistDeviceInfo();
+        this.loadDeviceSettings();
+        const modifiedOptions = lodash_1.default.cloneDeep(options);
+        modifiedOptions.connectionOptions.resultConfig = {
+            flatten: true,
+        };
+        this.config = modifiedOptions;
+        this.client = new lib_1.DachsHttpClient(this.config.connectionOptions, this.log.bind(this));
+        this.warmWaterSensor = new dachsTemperatureSensor_1.DachsTemperatureSensor(this.config.roomName, 'ww', 'Water Temperature');
+        this.heatStorageTempSensor = new dachsTemperatureSensor_1.DachsTemperatureSensor(this.config.roomName, 'hs', 'Heat Storage Temperature');
+        utils_1.Utils.guardedInterval(this.loadData, this.config.refreshInterval, this);
+        this.blockAutomationHandler = new services_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
+        if ((_b = (_a = devices_1.Devices.energymanager) === null || _a === void 0 ? void 0 : _a.deviceCapabilities) === null || _b === void 0 ? void 0 : _b.includes(enums_1.DeviceCapability.batteryDriven)) {
+            const energyManager = devices_1.Devices.energymanager;
+            energyManager.battery.addBatteryLevelCallback(this.onBatteryLevelChange.bind(this));
+        }
+        this.warmWaterSensor.addTempChangeCallback(this.onWarmWaterTempChange.bind(this));
+        this.heatStorageTempSensor.addTempChangeCallback(this.onHeatStorageTempChange.bind(this));
+    }
+    /** @inheritDoc */
+    get info() {
+        return this._info;
+    }
+    /** @inheritDoc */
+    get id() {
+        var _a;
+        return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `sonos-${this.info.room}-${this.info.customName}`;
+    }
+    /** @inheritDoc */
+    get room() {
+        return api_1.API.getRoom(this.info.room);
+    }
+    get name() {
+        return this.info.customName;
+    }
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c) {
+        this.log(enums_1.LogLevel.Debug, 'Restore Target Automatic value');
+        this.setActuator(new command_1.ActuatorSetStateCommand(c, this.targetAutomaticState, 'Restore Target Automatic value'));
+    }
+    /** @inheritDoc */
+    log(level, message, debugType = enums_1.LogDebugType.None) {
+        logging_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
+            debugType: debugType,
+            deviceId: this.name,
+            room: this._info.room,
+            deviceName: this.name,
+        });
+    }
+    /** @inheritDoc */
+    toJSON() {
+        return utils_1.Utils.jsonFilter(lodash_1.default.omit(this, [
+            'room',
+            'client',
+            'config',
+            '_influxClient',
+            'warmWaterSensor',
+            'heatStorageTempSensor',
+            'warmWaterPump',
+            'heatingRod',
+            'blockDachsStart',
+            'warmWaterDachsAlternativeActuator',
+        ]));
+    }
+    /** @inheritDoc */
+    persistDeviceInfo() {
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
+        }, 5000, this);
+    }
+    /** @inheritDoc */
+    loadDeviceSettings() {
+        this.settings.initializeFromDb(this);
+    }
+    /** @inheritDoc */
+    persist() {
+        var _a;
+        (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+    }
+    loadData() {
+        this.client
+            .fetchAllKeys()
+            .then((data) => {
+            var _a, _b;
+            this.queuedValue = null;
+            this.fetchedData = data;
+            if (this._influxClient === undefined) {
+                return;
+            }
+            for (const key in data) {
+                const value = data[key];
+                if (typeof value === 'number') {
+                    this._influxClient.addMeasurementToQueue(key, value);
+                    continue;
+                }
+                this._influxClient.addMeasurementToQueue(key, value ? '1' : '0');
+            }
+            this._influxClient.flush();
+            const isDachsOn = this.fetchedData['Hka_Mw1.usDrehzahl'] >= 1;
+            const didDachsChange = this._dachsOn !== isDachsOn;
+            this._dachsOn = isDachsOn;
+            this._dachsOn = this.fetchedData['Hka_Mw1.usDrehzahl'] >= 1;
+            this._tempWarmWater = (_a = this.fetchedData['Hka_Mw1.Temp.sbZS_Warmwasser']) !== null && _a !== void 0 ? _a : 0;
+            this.warmWaterSensor.update(this._tempWarmWater);
+            this._tempHeatStorage = (_b = this.fetchedData['Hka_Mw1.Temp.sbFuehler1']) !== null && _b !== void 0 ? _b : 0;
+            this.heatStorageTempSensor.update(this._tempHeatStorage);
+            if (didDachsChange) {
+                this.onDachsRunningStateChange(new action_1.ActuatorChangeAction(this));
+            }
+            this.persist();
+        })
+            .catch((error) => {
+            this.log(enums_1.LogLevel.Error, `Error while fetching data: ${error}`, enums_1.LogDebugType.DachsUnreach);
+        });
+    }
+    /** @inheritDoc */
+    setActuator(c) {
+        sharedFunctions_1.LampUtils.setActuator(this, c);
+        if (!c.on ||
+            !this.warmWaterPump ||
+            (this.queuedValue === false && !this._dachsOn) ||
+            this.heatStorageTempSensor.temperatureSensor.temperature < this.warmWaterSensor.temperatureSensor.temperature) {
+            return;
+        }
+        const startPumpCommand = new command_1.ActuatorSetStateCommand(c, true, 'Dachs is starting/on');
+        this.warmWaterPump.setActuator(startPumpCommand);
+    }
+    /** @inheritDoc */
+    toggleActuator(c) {
+        const setActuatorCommand = new command_1.ActuatorSetStateCommand(c, this.queuedValue !== null ? !this.queuedValue : !this.actuatorOn, 'Due to ActuatorToggle', c.isForceAction ? undefined : null);
+        this.setActuator(setActuatorCommand);
+        return setActuatorCommand.on;
+    }
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c) {
+        this.log(enums_1.LogLevel.Debug, c.logMessage, enums_1.LogDebugType.SetActuator);
+        if (!c.stateValue) {
+            return;
+        }
+        this.client
+            .setKeys({
+            'Stromf_Ew.Anforderung_GLT.bAktiv': '1',
+            'Stromf_Ew.Anforderung_GLT.bAnzahlModule': '1',
+        })
+            .then((response) => {
+            this.log(enums_1.LogLevel.Debug, `Dachs started resulted in status: ${response.status}, data: ${response.data}`);
+            utils_1.Utils.guardedTimeout(() => {
+                this.client
+                    .setKeys({
+                    'Stromf_Ew.Anforderung_GLT.bAktiv': '0',
+                    'Stromf_Ew.Anforderung_GLT.bAnzahlModule': '0',
+                })
+                    .catch((error) => {
+                    this.log(enums_1.LogLevel.Error, `Error while turning off Dachs: ${error}`);
+                });
+            }, 30000, this);
+        })
+            .catch((error) => {
+            this.log(enums_1.LogLevel.Error, `Error while turning on Dachs: ${error}`);
+        });
+    }
+    /**
+     * Reacts on level Changes of a Energymanager with battery
+     * @param {BatteryLevelChangeAction} action - The action containing the new level
+     */
+    onBatteryLevelChange(action) {
+        this.checkAllDesiredStates(action, action.newLevel);
+    }
+    checkAllDesiredStates(action, batteryLevel) {
+        const shouldDachsBeStarted = this.shouldDachsBeStarted(action, batteryLevel);
+        this.checkHeatingRod(action, batteryLevel);
+        this.checkAlternativeActuator(shouldDachsBeStarted, action);
+        this.checkWwPumpDesiredState(action);
+        if (!shouldDachsBeStarted) {
+            return;
+        }
+        const setStateCommand = new command_1.ActuatorSetStateCommand(action, true, 'Energy Level of battery dropped to critical level', null);
+        setStateCommand.overrideCommandSource = enums_1.CommandSource.Force;
+        this.setActuator(setStateCommand);
+    }
+    onHeatStorageTempChange(action) {
+        var _a, _b;
+        this.checkAllDesiredStates(action, (_b = (_a = devices_1.Devices.energymanager) === null || _a === void 0 ? void 0 : _a.batteryLevel) !== null && _b !== void 0 ? _b : 0);
+    }
+    onWarmWaterTempChange(action) {
+        var _a, _b;
+        this.checkAllDesiredStates(action, (_b = (_a = devices_1.Devices.energymanager) === null || _a === void 0 ? void 0 : _a.batteryLevel) !== null && _b !== void 0 ? _b : 0);
+    }
+    checkWwPumpDesiredState(action) {
+        var _a, _b;
+        if (this.warmWaterPump === undefined) {
+            // We have no control over the warm water pump --> nothing to do
+            return;
+        }
+        const wwTemp = this._tempWarmWater;
+        const heatStorageTemp = this._tempHeatStorage;
+        let desiredWwPumpState = false;
+        let reason = '';
+        if (((_a = this.warmWaterDachsAlternativeActuator) === null || _a === void 0 ? void 0 : _a.actuatorOn) === true) {
+            desiredWwPumpState = false;
+            reason = 'Alternative heating source is on';
+        }
+        else if (wwTemp > heatStorageTemp) {
+            desiredWwPumpState = false;
+            reason = `Temperature of warm water pump ${wwTemp}°C is higher than temperature of heat storage ${heatStorageTemp}°C`;
+        }
+        else if (this._dachsOn) {
+            desiredWwPumpState = true;
+            reason = 'Dachs is on anyways';
+        }
+        else if (((_b = this.blockDachsStart) === null || _b === void 0 ? void 0 : _b.actuatorOn) === false) {
+            desiredWwPumpState = true;
+            reason = 'Dachs is not blocked --> lowering storage temp might trigger it.';
+        }
+        else if (wwTemp > this.settings.warmWaterDesiredMinTemp + 3) {
+            desiredWwPumpState = false;
+            reason = `Temperature of warm water pump ${wwTemp}°C is above desired minimum temperature ${this.settings.warmWaterDesiredMinTemp}°C`;
+        }
+        else if (heatStorageTemp < this.settings.warmWaterDesiredMinTemp - 4) {
+            desiredWwPumpState = false;
+            reason = `Temperature of heat storage ${heatStorageTemp}°C is too low to heat water.`;
+        }
+        else if (wwTemp < this.settings.warmWaterDesiredMinTemp) {
+            desiredWwPumpState = true;
+            reason = `Temperature of warm water pump ${wwTemp}°C is lower than desired minimum temperature ${this.settings.warmWaterDesiredMinTemp}°C`;
+        }
+        else {
+            // We are somewhere between states, let's not change anything
+            return;
+        }
+        if (desiredWwPumpState === this.warmWaterPump.actuatorOn) {
+            // Nothing to do
+            return;
+        }
+        const setAction = new command_1.ActuatorSetStateCommand(action, desiredWwPumpState, reason, null);
+        this.warmWaterPump.setActuator(setAction);
+    }
+    checkHeatingRod(action, batteryLevel) {
+        if (this.heatingRod === undefined) {
+            return;
+        }
+        const shouldBeOff = batteryLevel < this.settings.batteryLevelHeatingRodThreshold;
+        if (this.heatingRod.actuatorOn !== shouldBeOff) {
+            return;
+        }
+        const setAction = new command_1.ActuatorSetStateCommand(action, !shouldBeOff, `Battery reached ${batteryLevel}%, heating rod should be turned ${shouldBeOff ? 'off' : 'on'}`, null);
+        this.heatingRod.setActuator(setAction);
+    }
+    shouldDachsBeStarted(action, batteryLevel) {
+        var _a, _b;
+        if (this.blockDachsStart !== undefined) {
+            if (batteryLevel > this.settings.batteryLevelPreventStartThreshold) {
+                const blockAction = new command_1.ActuatorSetStateCommand(action, true, `Battery reached ${batteryLevel}%, Dachs should not run any more`, null);
+                blockAction.overrideCommandSource = enums_1.CommandSource.Force;
+                this.blockDachsStart.setActuator(blockAction);
+                return false;
+            }
+            else if (batteryLevel < this.settings.batteryLevelAllowStartThreshold) {
+                const liftAction = new command_1.ActuatorSetStateCommand(action, false, `Battery reached ${batteryLevel}%, Dachs is now allowed to run if needed`, null);
+                this.blockDachsStart.setActuator(liftAction);
+            }
+            else if (((_a = settings_service_1.SettingsService.settings.heaterSettings) === null || _a === void 0 ? void 0 : _a.mode) === enums_1.HeatingMode.Winter &&
+                this.heatStorageTempSensor.temperatureSensor.temperature < this.settings.winterMinimumPreNightHeatStorageTemp &&
+                utils_1.Utils.dateByTimeSpan(21, 30) < new Date()) {
+                const liftWinterAction = new command_1.ActuatorSetStateCommand(action, false, `Battery at ${batteryLevel}% but it is winter, we are nearing night and heat storage is kinda cold: Dachs is now allowed to run if needed`, null);
+                this.blockDachsStart.setActuator(liftWinterAction);
+            }
+            else if (this.blockDachsStart.actuatorOn) {
+                // We haven't reached the lower threshold yet --> nothing to do
+                return false;
+            }
+        }
+        if (this._dachsOn) {
+            // We are already running
+            return false;
+        }
+        if (((_b = settings_service_1.SettingsService.settings.heaterSettings) === null || _b === void 0 ? void 0 : _b.mode) === enums_1.HeatingMode.Winter &&
+            this.heatStorageTempSensor.temperatureSensor.temperature < this.settings.winterMinimumHeatStorageTemp) {
+            // It is winter and heat storage is kinda cold --> Start
+            return true;
+        }
+        const dayType = services_1.TimeCallbackService.dayType(new sun_time_offsets_1.SunTimeOffsets());
+        if ((dayType === enums_1.TimeOfDay.Daylight || dayType === enums_1.TimeOfDay.BeforeSunrise) &&
+            batteryLevel > this.settings.batteryLevelTurnOnThreshold) {
+            // It is daytime (maybe solar power) and it is no critical battery level
+            return false;
+        }
+        if (batteryLevel > this.settings.batteryLevelBeforeNightTurnOnThreshold) {
+            // It is not daylight but battery level is high enough
+            return false;
+        }
+        return true;
+    }
+    checkAlternativeActuator(shouldDachsBeStarted, action) {
+        var _a, _b;
+        if (!this.warmWaterDachsAlternativeActuator) {
+            return;
+        }
+        let desiredState = false;
+        let reason = 'Dachs is allowed to run --> Block alternative heating source';
+        if (shouldDachsBeStarted || this._dachsOn) {
+            reason = 'Dachs is running or should be started';
+            desiredState = false;
+        }
+        else if (((_a = this.blockDachsStart) === null || _a === void 0 ? void 0 : _a.actuatorOn) === true || ((_b = this.blockDachsStart) === null || _b === void 0 ? void 0 : _b.queuedValue) === true) {
+            reason = 'Dachs is blocked --> Allow Alternative Heating Source';
+            desiredState = true;
+        }
+        if (this.warmWaterDachsAlternativeActuator.actuatorOn === desiredState) {
+            return;
+        }
+        const command = new command_1.ActuatorSetStateCommand(action, desiredState, reason, null);
+        command.overrideCommandSource = enums_1.CommandSource.Force;
+        this.warmWaterDachsAlternativeActuator.setActuator(command);
+    }
+    onDachsRunningStateChange(runStateChange) {
+        var _a, _b;
+        this.checkAllDesiredStates(runStateChange, (_b = (_a = devices_1.Devices.energymanager) === null || _a === void 0 ? void 0 : _a.batteryLevel) !== null && _b !== void 0 ? _b : 0);
+    }
+}
+exports.Dachs = Dachs;

package/lib/devices/dachs/dachsTemperatureSensor.d.ts

@@ -0,0 +1,51 @@
+import { iRoomBase, iTemperatureCollector } from '../../interfaces';
+import { DeviceSettings } from '../../settingsObjects';
+import { DeviceCapability, DeviceType, LogDebugType, LogLevel } from '../../enums';
+import { TemperatureSensor } from '../sharedFunctions';
+import { DeviceInfo } from '../DeviceInfo';
+import { OwnSonosDevice } from '../../services';
+import { TemperatureSensorChangeAction } from '../../action';
+export declare class DachsTemperatureSensor implements iTemperatureCollector {
+    /** @inheritDoc */
+    settings: DeviceSettings | undefined;
+    /** @inheritDoc */
+    readonly deviceType: DeviceType;
+    /** @inheritDoc */
+    readonly deviceCapabilities: DeviceCapability[];
+    /** @inheritDoc */
+    temperatureSensor: TemperatureSensor;
+    protected _info: DeviceInfo;
+    constructor(roomName: string, shortKey: string, longKey: string);
+    /** @inheritDoc */
+    get customName(): string;
+    /** @inheritDoc */
+    get info(): DeviceInfo;
+    /** @inheritDoc */
+    get id(): string;
+    get name(): string;
+    /** @inheritDoc */
+    get room(): iRoomBase | undefined;
+    /** @inheritDoc */
+    get roomTemperature(): number;
+    /** @inheritDoc */
+    set roomTemperature(value: number);
+    /** @inheritDoc */
+    get iTemperature(): number;
+    /** @inheritDoc */
+    get sTemperature(): string;
+    update(newTemp: number): void;
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback: (action: TemperatureSensorChangeAction) => void): void;
+    /** @inheritDoc */
+    onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
+    log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    /** @inheritDoc */
+    toJSON(): Partial<OwnSonosDevice>;
+    /** @inheritDoc */
+    persistDeviceInfo(): void;
+    /** @inheritDoc */
+    loadDeviceSettings(): void;
+    /** @inheritDoc */
+    dispose(): void;
+}

package/lib/devices/dachs/dachsTemperatureSensor.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DachsTemperatureSensor = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const enums_1 = require("../../enums");
+const sharedFunctions_1 = require("../sharedFunctions");
+const DeviceInfo_1 = require("../DeviceInfo");
+const devices_1 = require("../devices");
+const utils_1 = require("../../utils");
+const api_1 = require("../../api");
+const logging_1 = require("../../logging");
+const services_1 = require("../../services");
+class DachsTemperatureSensor {
+    constructor(roomName, shortKey, longKey) {
+        /** @inheritDoc */
+        this.settings = undefined;
+        /** @inheritDoc */
+        this.deviceType = enums_1.DeviceType.DachsWarmWaterTemperature;
+        /** @inheritDoc */
+        this.deviceCapabilities = [];
+        /** @inheritDoc */
+        this.temperatureSensor = new sharedFunctions_1.TemperatureSensor(this);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.temperatureSensor);
+        this._info = new DeviceInfo_1.DeviceInfo();
+        this._info.fullName = longKey;
+        this._info.customName = `${longKey} ${roomName}`;
+        this._info.allDevicesKey = `dachs-${shortKey}-${roomName}`;
+        this._info.room = roomName;
+        devices_1.Devices.alLDevices[this._info.allDevicesKey] = this;
+        devices_1.Devices.temperatureWarmWater = this;
+        this.persistDeviceInfo();
+        utils_1.Utils.guardedTimeout(this.loadDeviceSettings, 200, this);
+    }
+    /** @inheritDoc */
+    get customName() {
+        return this.info.customName;
+    }
+    /** @inheritDoc */
+    get info() {
+        return this._info;
+    }
+    /** @inheritDoc */
+    get id() {
+        var _a;
+        return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `dachs-${this.info.room}-${this.info.customName}`;
+    }
+    get name() {
+        return this.info.customName;
+    }
+    /** @inheritDoc */
+    get room() {
+        return api_1.API.getRoom(this.info.room);
+    }
+    /** @inheritDoc */
+    get roomTemperature() {
+        return this.temperatureSensor.roomTemperature;
+    }
+    /** @inheritDoc */
+    set roomTemperature(value) {
+        this.temperatureSensor.roomTemperature = value;
+    }
+    /** @inheritDoc */
+    get iTemperature() {
+        return this.temperatureSensor.temperature;
+    }
+    /** @inheritDoc */
+    get sTemperature() {
+        return `${this.temperatureSensor.temperature}°C`;
+    }
+    update(newTemp) {
+        this.temperatureSensor.temperature = newTemp;
+    }
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback) {
+        this.temperatureSensor.addTempChangeCallback(pCallback);
+    }
+    /** @inheritDoc */
+    onTemperaturChange(newTemperatur) {
+        this.roomTemperature = newTemperatur;
+    }
+    /** @inheritDoc */
+    log(level, message, debugType = enums_1.LogDebugType.None) {
+        logging_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
+            debugType: debugType,
+            deviceId: this.name,
+            room: this._info.room,
+            deviceName: this.name,
+        });
+    }
+    /** @inheritDoc */
+    toJSON() {
+        return utils_1.Utils.jsonFilter(lodash_1.default.omit(this, ['room', 'client', 'config', '_influxClient']));
+    }
+    /** @inheritDoc */
+    persistDeviceInfo() {
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
+        }, 5000, this);
+    }
+    /** @inheritDoc */
+    loadDeviceSettings() {
+        var _a;
+        (_a = this.settings) === null || _a === void 0 ? void 0 : _a.initializeFromDb(this);
+    }
+    /** @inheritDoc */
+    dispose() {
+        this.temperatureSensor.dispose();
+    }
+}
+exports.DachsTemperatureSensor = DachsTemperatureSensor;

package/lib/devices/dachs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dachs';
+export * from './lib';

package/lib/devices/dachs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./dachs"), exports);
+__exportStar(require("./lib"), exports);

package/lib/devices/dachs/lib/ReadKeyList.d.ts

@@ -0,0 +1,3 @@
+import { IReadKeyList, KeyListEntity } from '../../../interfaces';
+declare const ReadKeyList: IReadKeyList<KeyListEntity>;
+export default ReadKeyList;

package/lib/devices/dachs/lib/WriteKeyList.d.ts

@@ -0,0 +1,3 @@
+import { IWriteKeyList } from '../../../interfaces';
+declare const WriteKeyList: IWriteKeyList;
+export default WriteKeyList;

package/lib/devices/dachs/lib/dachsHttpClient.d.ts

@@ -0,0 +1,49 @@
+import { AxiosResponse } from 'axios';
+import { DachsClientOptions, iFlattenedCompleteResponse, KeyListEntityResponse } from '../../../interfaces';
+import { LogDebugType, LogLevel } from '../../../enums';
+/**
+ * axios HTTP Client Class
+ * - with some prepared fetch functions for data
+ * @author Trickfilm400
+ * @version 1
+ * @class
+ */
+export declare class DachsHttpClient {
+    private readonly _logger;
+    private options;
+    private readonly url;
+    private axiosInstance;
+    constructor(options: DachsClientOptions, _logger: (level: LogLevel, message: string, logDebugType?: LogDebugType) => void);
+    /**
+     * Takes every key and add the key to the get parameter list
+     * @param {string[]} keys - Array of request keys
+     * @private
+     * @author Trickfilm400
+     * @version 1
+     * @return {string} The final and complete get parameter string
+     */
+    private urlBuilder;
+    /**
+     * main request function
+     * @author Trickfilm400
+     * @version 1
+     * @param {string[]} keys - Array of request keys
+     * @return Promise
+     */
+    fetchByKeys(...keys: string[]): Promise<{
+        [id: string]: KeyListEntityResponse<string | number | boolean>;
+    }>;
+    fetchAllKeys(): Promise<iFlattenedCompleteResponse>;
+    setKeys(data: {
+        [key: string]: string;
+    }): Promise<AxiosResponse<string>>;
+    /**
+     * Parses the RAW HTTP Response from the request into key-value paris
+     * @author Trickfilm400
+     * @version 1
+     * @param {string} res - The raw Result from the HTTP Request
+     * @return Partial<IReadKeyList> The parsed key value pairs from the result in a JSON
+     * @private
+     */
+    private parser;
+}