hoffmation-base 2.22.18 → 3.0.0-alpha.0

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

@@ -0,0 +1,25 @@
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { BaseCommand } from './baseCommand';
+import { DimmerSetLightCommand } from './dimmerSetLightCommand';
+import { LampSetTimeBasedCommand } from './lampSetTimeBasedCommand';
+import { LedSettings } from '../deviceSettings';
+export declare class LedSetLightCommand extends DimmerSetLightCommand {
+    color: string;
+    colorTemp: number;
+    _commandType: CommandType;
+    /**
+     *
+     * @param {CommandSource | BaseCommand} source
+     * @param {boolean} on
+     * @param {string} reason
+     * @param {number} timeout  A chosen Timeout after which the light should be reset
+     * @param {number} brightness The desired brightness
+     * @param {number} transitionTime The transition time during turnOn/turnOff
+     * @param {string} color The desired color in 6 digit hex Code
+     * @param {number} colorTemp The desired color Temperature (0 = more White)
+     */
+    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, timeout?: number, brightness?: number, transitionTime?: number, color?: string, colorTemp?: number);
+    get logMessage(): string;
+    static byTimeBased(settings: LedSettings, c: LampSetTimeBasedCommand): LedSetLightCommand;
+}

package/lib/models/command/ledSetLightCommand.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedSetLightCommand = void 0;
+const commandType_1 = require("./commandType");
+const dimmerSetLightCommand_1 = require("./dimmerSetLightCommand");
+const timeCallback_1 = require("../timeCallback");
+class LedSetLightCommand extends dimmerSetLightCommand_1.DimmerSetLightCommand {
+    /**
+     *
+     * @param {CommandSource | BaseCommand} source
+     * @param {boolean} on
+     * @param {string} reason
+     * @param {number} timeout  A chosen Timeout after which the light should be reset
+     * @param {number} brightness The desired brightness
+     * @param {number} transitionTime The transition time during turnOn/turnOff
+     * @param {string} color The desired color in 6 digit hex Code
+     * @param {number} colorTemp The desired color Temperature (0 = more White)
+     */
+    constructor(source, on, reason = '', timeout = -1, brightness, transitionTime, color = '', colorTemp = -1) {
+        super(source, on, reason, timeout, brightness, transitionTime);
+        this.color = color;
+        this.colorTemp = colorTemp;
+        this._commandType = commandType_1.CommandType.LedSetLightCommand;
+    }
+    get logMessage() {
+        return `Led setLight to ${this.on} from ${this.source} for reason: ${this.reasonTrace}`;
+    }
+    static byTimeBased(settings, c) {
+        switch (c.time) {
+            case timeCallback_1.TimeOfDay.Daylight:
+                return new LedSetLightCommand(c, settings.dayOn, '', c.timeout, settings.dayBrightness, undefined, settings.dayColor, settings.dayColorTemp);
+            case timeCallback_1.TimeOfDay.BeforeSunrise:
+                return new LedSetLightCommand(c, settings.dawnOn, '', c.timeout, settings.dawnBrightness, undefined, settings.dawnColor, settings.dawnColorTemp);
+            case timeCallback_1.TimeOfDay.AfterSunset:
+                return new LedSetLightCommand(c, settings.duskOn, '', c.timeout, settings.duskBrightness, undefined, settings.duskColor, settings.duskColorTemp);
+            case timeCallback_1.TimeOfDay.Night:
+                return new LedSetLightCommand(c, settings.nightOn, '', c.timeout, settings.nightBrightness, undefined, settings.nightColor, settings.nightColorTemp);
+        }
+    }
+}
+exports.LedSetLightCommand = LedSetLightCommand;

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

@@ -0,0 +1,9 @@
+import { BaseCommand } from './baseCommand';
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { TimeOfDay } from '../timeCallback';
+export declare class LightGroupSwitchTimeConditionalCommand extends BaseCommand {
+    readonly time: TimeOfDay;
+    _commandType: CommandType;
+    constructor(source: CommandSource | BaseCommand, time: TimeOfDay, reason?: string);
+}

package/lib/models/command/lightGroupSwitchTimeConditionalCommand.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightGroupSwitchTimeConditionalCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class LightGroupSwitchTimeConditionalCommand extends baseCommand_1.BaseCommand {
+    constructor(source, time, reason = '') {
+        super(source, reason);
+        this.time = time;
+        this._commandType = commandType_1.CommandType.LightGroupSwitchTimeConditional;
+    }
+}
+exports.LightGroupSwitchTimeConditionalCommand = LightGroupSwitchTimeConditionalCommand;

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

@@ -0,0 +1,8 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource } from './commandSource';
+import { CommandType } from './commandType';
+export declare class RestoreTargetAutomaticValueCommand extends BaseCommand {
+    _commandType: CommandType;
+    constructor(source: CommandSource | BaseCommand, reason?: string);
+    get logMessage(): string;
+}

package/lib/models/command/restoreTargetAutomaticValueCommand.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestoreTargetAutomaticValueCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class RestoreTargetAutomaticValueCommand extends baseCommand_1.BaseCommand {
+    constructor(source, reason = '') {
+        super(source, reason);
+        this._commandType = commandType_1.CommandType.ActuatorRestoreTargetAutomaticValueCommand;
+    }
+    get logMessage() {
+        return `Actuator restore target automatic value from ${this.source} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.RestoreTargetAutomaticValueCommand = RestoreTargetAutomaticValueCommand;

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

@@ -0,0 +1,7 @@
+import { BaseCommand } from './baseCommand';
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+export declare class RoomRestoreLightCommand extends BaseCommand {
+    _commandType: CommandType;
+    constructor(source: CommandSource | BaseCommand, reason?: string);
+}

package/lib/models/command/roomRestoreLightCommand.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomRestoreLightCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class RoomRestoreLightCommand extends baseCommand_1.BaseCommand {
+    constructor(source, reason = '') {
+        super(source, reason);
+        this._commandType = commandType_1.CommandType.RoomRestoreLightCommand;
+    }
+}
+exports.RoomRestoreLightCommand = RoomRestoreLightCommand;

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

@@ -0,0 +1,8 @@
+import { CommandSource } from './commandSource';
+import { BaseCommand } from './baseCommand';
+import { CommandType } from './commandType';
+export declare class RoomRestoreShutterPositionCommand extends BaseCommand {
+    readonly recalc: boolean;
+    _commandType: CommandType;
+    constructor(source: CommandSource | BaseCommand, recalc?: boolean, reason?: string);
+}

package/lib/models/command/roomRestoreShutterPositionCommand.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomRestoreShutterPositionCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class RoomRestoreShutterPositionCommand extends baseCommand_1.BaseCommand {
+    constructor(source, recalc = false, reason = '') {
+        super(source, reason);
+        this.recalc = recalc;
+        this._commandType = commandType_1.CommandType.RoomRestoreShutterPositionCommand;
+    }
+}
+exports.RoomRestoreShutterPositionCommand = RoomRestoreShutterPositionCommand;

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

@@ -0,0 +1,14 @@
+import { BaseCommand } from './baseCommand';
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+export declare class RoomSetLightTimeBasedCommand extends BaseCommand {
+    readonly movementDependant: boolean;
+    _commandType: CommandType;
+    /**
+     * 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
+     */
+    constructor(source: CommandSource | BaseCommand, movementDependant?: boolean, reason?: string);
+}

package/lib/models/command/roomSetLightTimeBasedCommand.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomSetLightTimeBasedCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+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
+     */
+    constructor(source, movementDependant = false, reason = '') {
+        super(source, reason);
+        this.movementDependant = movementDependant;
+        this._commandType = commandType_1.CommandType.RoomSetLightTimeBasedCommand;
+    }
+}
+exports.RoomSetLightTimeBasedCommand = RoomSetLightTimeBasedCommand;

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

@@ -0,0 +1,7 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource } from './commandSource';
+import { CommandType } from './commandType';
+export declare class ShutterSunriseUpCommand extends BaseCommand {
+    _commandType: CommandType;
+    constructor(source: CommandSource | BaseCommand, reason?: string);
+}

package/lib/models/command/shutterSunriseUpCommand.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShutterSunriseUpCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class ShutterSunriseUpCommand extends baseCommand_1.BaseCommand {
+    constructor(source, reason = '') {
+        super(source, reason);
+        this._commandType = commandType_1.CommandType.ShutterSunriseUpCommand;
+    }
+}
+exports.ShutterSunriseUpCommand = ShutterSunriseUpCommand;

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

@@ -0,0 +1,7 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource } from './commandSource';
+import { CommandType } from './commandType';
+export declare class ShutterSunsetDownCommand extends BaseCommand {
+    _commandType: CommandType;
+    constructor(source: CommandSource | BaseCommand, reason?: string);
+}

package/lib/models/command/shutterSunsetDownCommand.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShutterSunsetDownCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class ShutterSunsetDownCommand extends baseCommand_1.BaseCommand {
+    constructor(source, reason = '') {
+        super(source, reason);
+        this._commandType = commandType_1.CommandType.SunsetDownCommand;
+    }
+}
+exports.ShutterSunsetDownCommand = ShutterSunsetDownCommand;

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

@@ -0,0 +1,12 @@
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { BaseCommand } from './baseCommand';
+import { DimmerSetLightCommand } from './dimmerSetLightCommand';
+import { WledSettings } from '../deviceSettings';
+import { LampSetTimeBasedCommand } from './lampSetTimeBasedCommand';
+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);
+    static byTimeBased(settings: WledSettings, c: LampSetTimeBasedCommand): WledSetLightCommand;
+}

package/lib/models/command/wledSetLightCommand.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WledSetLightCommand = void 0;
+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);
+        this.preset = preset;
+        this._commandType = commandType_1.CommandType.WledSetLightCommand;
+    }
+    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);
+            case timeCallback_1.TimeOfDay.BeforeSunrise:
+                return new WledSetLightCommand(c, settings.dawnOn, '', c.timeout, settings.dawnBrightness, undefined, settings.dawnPreset);
+            case timeCallback_1.TimeOfDay.AfterSunset:
+                return new WledSetLightCommand(c, settings.duskOn, '', c.timeout, settings.duskBrightness, undefined, settings.duskPreset);
+            case timeCallback_1.TimeOfDay.Night:
+                return new WledSetLightCommand(c, settings.nightOn, '', c.timeout, settings.nightBrightness, undefined, settings.nightPreset);
+            default:
+                throw new Error(`TimeOfDay ${c.time} not supported`);
+        }
+    }
+}
+exports.WledSetLightCommand = WledSetLightCommand;

package/lib/models/index.d.ts

@@ -4,6 +4,7 @@ export * from './persistence/index';
 export * from './base64Image';
 export * from './collisionSolving';
 export * from './connectionCallbacks';
+export * from './command';
 export * from './daytime';
 export * from './deviceConfig';
 export * from './excessEnergyConsumerSettings';

package/lib/models/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./persistence/index"), exports);
 __exportStar(require("./base64Image"), exports);
 __exportStar(require("./collisionSolving"), exports);
 __exportStar(require("./connectionCallbacks"), exports);
+__exportStar(require("./command"), exports);
 __exportStar(require("./daytime"), exports);
 __exportStar(require("./deviceConfig"), exports);
 __exportStar(require("./excessEnergyConsumerSettings"), exports);

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

@@ -5,6 +5,7 @@ import { RoomSettingsController } from './RoomSettings';
 import { iRoomBase } from './iRoomBase';
 import { RoomInfo } from './roomInfo';
 import { iIdHolder } from '../iIdHolder';
+import { RoomSetLightTimeBasedCommand } from '../command';
 export declare class RoomBase implements iRoomBase, iIdHolder {
     groupMap: Map<GroupType, BaseGroup>;
     info: RoomInfo;
@@ -38,9 +39,8 @@ export declare class RoomBase implements iRoomBase, iIdHolder {
     recalcTimeCallbacks(): void;
     /**
      * Sets the light based on the current time, rollo Position and room Settings
-     * @param movementDependant Only turn light on if there was a movement in the same room
      */
-    setLightTimeBased(movementDependant?: boolean): void;
+    setLightTimeBased(c: RoomSetLightTimeBasedCommand): void;
     isNowLightTime(): boolean;
     toJSON(): Partial<RoomBase & {
         groupDict?: {

package/lib/models/rooms/RoomBase.js

@@ -10,6 +10,7 @@ const logLevel_1 = require("../logLevel");
 const RoomSettings_1 = require("./RoomSettings");
 const roomInfo_1 = require("./roomInfo");
 const lodash_1 = __importDefault(require("lodash"));
+const command_1 = require("../command");
 class RoomBase {
     constructor(groupMap, roomName, etage = 99, startPoint, endPoint) {
         this.groupMap = groupMap;
@@ -105,17 +106,16 @@ class RoomBase {
     }
     /**
      * Sets the light based on the current time, rollo Position and room Settings
-     * @param movementDependant Only turn light on if there was a movement in the same room
      */
-    setLightTimeBased(movementDependant = false) {
+    setLightTimeBased(c) {
         var _a, _b;
         if (!this.LightGroup) {
             this.log(logLevel_1.LogLevel.Trace, 'Ignore "setLightTimeBased" as we have no lamps');
             return;
         }
-        if (movementDependant && this.PraesenzGroup && !((_a = this.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.anyPresent())) {
+        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(false);
+            this.LightGroup.switchAll(new command_1.ActuatorSetStateCommand(c, false, 'Room.setLightTimeBased but no one is present'));
             return;
         }
         if (!this.settings.lampOffset && !this.settings.roomIsAlwaysDark) {
@@ -132,7 +132,7 @@ class RoomBase {
                 })))) {
             timeOfDay = server_1.Utils.nowTime().hours > 16 ? timeCallback_1.TimeOfDay.AfterSunset : timeCallback_1.TimeOfDay.BeforeSunrise;
         }
-        this.LightGroup.switchTimeConditional(timeOfDay);
+        this.LightGroup.switchTimeConditional(new command_1.LightGroupSwitchTimeConditionalCommand(c, timeOfDay, 'Roombase.setLightTimeBased'));
     }
     isNowLightTime() {
         var _a;

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

@@ -1,4 +1,5 @@
 import { TimeCallback } from '../timeCallback';
+import { RoomSetLightTimeBasedCommand } from '../command';
 export interface iRoomBase {
     sunriseShutterCallback: TimeCallback | undefined;
     sunsetShutterCallback: TimeCallback | undefined;
@@ -9,10 +10,6 @@ export interface iRoomBase {
     initializeBase(): void;
     persist(): void;
     recalcTimeCallbacks(): void;
-    /**
-     * Sets the light based on the current time, rollo Position and room Settings
-     * @param movementDependant Only turn light on if there was a movement in the same room
-     */
-    setLightTimeBased(movementDependant: boolean): void;
+    setLightTimeBased(c: RoomSetLightTimeBasedCommand): void;
     isNowLightTime(): boolean;
 }

package/lib/server/devices/baseDeviceInterfaces/iActuator.d.ts

@@ -1,4 +1,4 @@
-import { ActuatorSettings } from '../../../models';
+import { ActuatorSetStateCommand, ActuatorSettings, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand } from '../../../models';
 import { iRoomDevice } from './iRoomDevice';
 import { iTemporaryDisableAutomatic } from './iTemporaryDisableAutomatic';
 export interface iActuator extends iRoomDevice, iTemporaryDisableAutomatic {
@@ -21,11 +21,10 @@ export interface iActuator extends iRoomDevice, iTemporaryDisableAutomatic {
     persist(): void;
     /**
      * Controls the power state of this actuator
-     * @param {boolean} pValue the new desired State
-     * @param {number} timeout if positive the time in ms, after which state should reset to automatic
-     * @param {boolean} force if true, this command isn't overwritten by automatic actions
      * Accessible in API
+     * @param command
      */
-    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleActuator(force: boolean): boolean;
+    setActuator(command: ActuatorSetStateCommand): void;
+    toggleActuator(command: ActuatorToggleCommand): boolean;
+    writeActuatorStateToDevice(command: ActuatorWriteStateToDeviceCommand): void;
 }

package/lib/server/devices/baseDeviceInterfaces/iDimmableLamp.d.ts

@@ -1,17 +1,12 @@
 import { iLamp } from './iLamp';
-import { DimmerSettings, TimeOfDay } from '../../../models';
+import { DimmerSetLightCommand, DimmerSettings, LampToggleLightCommand } from '../../../models';
 export interface iDimmableLamp extends iLamp {
     settings: DimmerSettings;
     readonly brightness: number;
-    toggleLight(time: TimeOfDay, force: boolean, calculateTime: boolean): void;
+    toggleLight(command: LampToggleLightCommand): void;
     /**
      * This function sets the light to a specific value
-     * @param pValue The desired value
-     * @param timeout A chosen Timeout after which the light should be reset
-     * @param force Wether it is a action based on a user action, to override certain rules
-     * @param brightness The desired brightness
-     * @param transitionTime The transition time during turnOn/turnOff
      * Accessible in API
      */
-    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number): void;
+    setLight(command: DimmerSetLightCommand): void;
 }

package/lib/server/devices/baseDeviceInterfaces/iLamp.d.ts

@@ -1,30 +1,20 @@
-import { TimeOfDay } from '../../../models';
+import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
 import { iActuator } from './iActuator';
 export interface iLamp extends iActuator {
     /**
      * The state value of the device
      */
     readonly lightOn: boolean;
-    /**
-     * Set's the lamp based on lamp settings for the current time
-     * @param {TimeOfDay} time The time to use for calculation of desired state
-     * @param {number} timeout If > 0 this is the time after which the lamp reverts to its original state
-     * @param {boolean} force To indicate a higher priority than automatic actions (e.g. a user pressing a button)
-     */
-    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    setTimeBased(command: LampSetTimeBasedCommand): void;
     /**
      * Toggles the state of the lamp
-     * @param {TimeOfDay} time The time to use for calculation of desired state
-     * @param {boolean} force To indicate a higher priority than automatic actions (e.g. a user pressing a button)
-     * @param {boolean} calculateTime Alternative to "time", if set the time will be calculated by the lamps room and its settings
+     * @param command
      */
-    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): void;
+    toggleLight(command: LampToggleLightCommand): void;
     /**
      * This function sets the light to a specific value
-     * @param pValue The desired value
-     * @param timeout A chosen Timeout after which the light should be reset
-     * @param force Wether it is a action based on a user action, to override certain rules
      * Accessible in API
+     * @param command
      */
-    setLight(pValue: boolean, timeout: number, force: boolean): void;
+    setLight(command: LampSetLightCommand): void;
 }

package/lib/server/devices/baseDeviceInterfaces/iLedRgbCct.d.ts

@@ -1,22 +1,8 @@
-import { LedSettings, TimeOfDay } from '../../../models';
+import { LedSetLightCommand, LedSettings } from '../../../models';
 import { iDimmableLamp } from './iDimmableLamp';
 export interface iLedRgbCct extends iDimmableLamp {
     settings: LedSettings;
     readonly color: string;
     readonly colortemp: number;
-    /**
-     * @inheritDoc
-     */
-    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
-    /**
-     * @inheritDoc
-     * @param pValue
-     * @param timeout
-     * @param force
-     * @param brightness
-     * @param transitionTime
-     * @param {string} color The desired color in 6 digit hex Code
-     * @param {number} colorTemp The desired color Temperature (0 = more White)
-     */
-    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number, color?: string, colorTemp?: number): void;
+    setLight(c: LedSetLightCommand): void;
 }

package/lib/server/devices/baseDeviceInterfaces/iShutter.d.ts

@@ -1,11 +1,11 @@
 import { Window } from '../groups';
 import { iRoomDevice } from './iRoomDevice';
-import { ShutterSettings } from '../../../models';
+import { ShutterSetLevelCommand, ShutterSettings } from '../../../models';
 export interface iShutter extends iRoomDevice {
     settings: ShutterSettings;
     currentLevel: number;
     desiredWindowShutterLevel: number;
     window: Window | undefined;
     persist(): void;
-    setLevel(pPosition: number, initial: boolean, skipOpenWarning?: boolean): void;
+    setLevel(command: ShutterSetLevelCommand): void;
 }

package/lib/server/devices/baseDeviceInterfaces/iTemporaryDisableAutomatic.d.ts

@@ -1,6 +1,7 @@
 import { BlockAutomaticHandler } from '../../services/blockAutomaticHandler';
 import { iBaseDevice } from './iBaseDevice';
+import { RestoreTargetAutomaticValueCommand } from '../../../models';
 export interface iTemporaryDisableAutomatic extends iBaseDevice {
     readonly blockAutomationHandler: BlockAutomaticHandler;
-    restoreTargetAutomaticValue(): void;
+    restoreTargetAutomaticValue(command: RestoreTargetAutomaticValueCommand): void;
 }

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

@@ -1,5 +1,5 @@
 import { DeviceInfo, DeviceType, iActuator, iBaseDevice } from '../../devices';
-import { LogLevel, RoomBase } from '../../../models';
+import { ActuatorSetStateCommand, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, LogLevel, RestoreTargetAutomaticValueCommand, RoomBase } from '../../../models';
 import { DeviceCapability } from '../DeviceCapability';
 import { LogDebugType, OwnSonosDevice } from '../../services';
 import { iDachsSettings } from '../../config/iDachsSettings';
@@ -28,7 +28,7 @@ export declare class Dachs implements iBaseDevice, iActuator {
     get tempWarmWater(): number;
     get tempHeatStorage(): number;
     constructor(options: iDachsSettings);
-    restoreTargetAutomaticValue(): void;
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
     protected _info: DeviceInfo;
     get info(): DeviceInfo;
     set info(info: DeviceInfo);
@@ -41,6 +41,7 @@ export declare class Dachs implements iBaseDevice, iActuator {
     loadDeviceSettings(): void;
     private loadData;
     persist(): void;
-    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleActuator(_force: boolean): boolean;
+    setActuator(c: ActuatorSetStateCommand): void;
+    toggleActuator(c: ActuatorToggleCommand): boolean;
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
 }

package/lib/server/devices/dachs/dachs.js

@@ -58,9 +58,9 @@ class Dachs {
         services_1.Utils.guardedInterval(this.loadData, this.config.refreshInterval, this);
         this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this));
     }
-    restoreTargetAutomaticValue() {
+    restoreTargetAutomaticValue(c) {
         this.log(models_1.LogLevel.Debug, `Restore Target Automatic value`);
-        this.setActuator(this.targetAutomaticState);
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState, 'Restore Target Automatic value'));
     }
     get info() {
         return this._info;
@@ -132,17 +132,19 @@ class Dachs {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
     }
-    setActuator(pValue, timeout, force) {
-        if (!pValue || this._dachsOn) {
-            // Dachs can only be turned on, not off
-            return;
-        }
-        const dontBlock = devices_1.LampUtils.checkUnBlock(this, force, pValue);
-        if (devices_1.LampUtils.checkBlockActive(this, force, pValue)) {
+    setActuator(c) {
+        devices_1.LampUtils.setActuator(this, c);
+    }
+    toggleActuator(c) {
+        const setActuatorCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, c);
+        this.setActuator(setActuatorCommand);
+        return setActuatorCommand.on;
+    }
+    writeActuatorStateToDevice(c) {
+        this.log(models_1.LogLevel.Debug, c.logMessage, services_1.LogDebugType.SetActuator);
+        if (!c.stateValue) {
             return;
         }
-        this.log(models_1.LogLevel.Debug, `Starting Dachs`);
-        this.queuedValue = pValue;
         this.client
             .setKeys({
             'Stromf_Ew.Anforderung_GLT.bAktiv': '1',
@@ -164,16 +166,6 @@ class Dachs {
             .catch((error) => {
             this.log(models_1.LogLevel.Error, `Error while turning on Dachs: ${error}`);
         });
-        if (timeout !== undefined && timeout > -1 && !dontBlock) {
-            this.blockAutomationHandler.disableAutomatic(timeout, models_1.CollisionSolving.overrideIfGreater);
-        }
-    }
-    toggleActuator(_force) {
-        if (!this._dachsOn) {
-            this.setActuator(true);
-            return true;
-        }
-        return false;
     }
 }
 exports.Dachs = Dachs;

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

@@ -1,5 +1,6 @@
 import { HmIpGriff } from '../hmIPDevices';
 import { WindowPosition } from '../models';
+import { WindowRestoreDesiredPositionCommand, WindowSetDesiredPositionCommand } from '../../../models';
 import { iShutter, iVibrationSensor } from '../baseDeviceInterfaces';
 import { BaseGroup } from './base-group';
 import { ZigbeeMagnetContact } from '../zigbee';
@@ -12,9 +13,8 @@ export declare class Window extends BaseGroup {
     constructor(roomName: string, handleIds?: string[], vibrationIds?: string[], shutterIds?: string[], magnetIds?: string[]);
     /**
      * sets the desired Pos and moves rollo to this level
-     * @param {number} value
      */
-    setDesiredPosition(value: number): void;
+    setDesiredPosition(c: WindowSetDesiredPositionCommand): void;
     getHandle(): HmIpGriff[];
     getMagnetContact(): ZigbeeMagnetContact[];
     getShutter(): iShutter[];
@@ -22,5 +22,5 @@ export declare class Window extends BaseGroup {
     griffeInPosition(pPosition: WindowPosition): number;
     initialize(): void;
     rolloPositionChange(pValue: number): void;
-    restoreDesiredPosition(): void;
+    restoreDesiredPosition(c: WindowRestoreDesiredPositionCommand): void;
 }