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

package/lib/models/command/WindowSetDesiredPositionCommand.js

@@ -4,10 +4,19 @@ exports.WindowSetDesiredPositionCommand = void 0;
 const baseCommand_1 = require("./baseCommand");
 const commandType_1 = require("./commandType");
 class WindowSetDesiredPositionCommand extends baseCommand_1.BaseCommand {
-    constructor(source, position, reason = '') {
+    /**
+     * Command to set the desired position of the shutter of a window
+     * @param source - The source of the command
+     * @param position - The desired position of the shutter (0 closed, 100 open)
+     * @param reason - You can provide a reason for clarification
+     * @param applyNewPosition - Whether this new position should be applied immediately
+     */
+    constructor(source, position, reason = '', applyNewPosition = true) {
         super(source, reason);
         this.position = position;
-        this._commandType = commandType_1.CommandType.WindowSetDesiredPositionCommand;
+        this.applyNewPosition = applyNewPosition;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.WindowSetDesiredPositionCommand;
     }
 }
 exports.WindowSetDesiredPositionCommand = WindowSetDesiredPositionCommand;

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

@@ -2,6 +2,12 @@ import { BaseCommand } from './baseCommand';
 import { CommandSource } from './commandSource';
 import { CommandType } from './commandType';
 export declare class WindowSetRolloByWeatherStatusCommand extends BaseCommand {
-    _commandType: CommandType;
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Command to set the desired position of the shutter of a window based on the weather status
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source: CommandSource | BaseCommand, reason?: string);
 }

package/lib/models/command/WindowSetRolloByWeatherStatusCommand.js

@@ -4,9 +4,15 @@ exports.WindowSetRolloByWeatherStatusCommand = void 0;
 const baseCommand_1 = require("./baseCommand");
 const commandType_1 = require("./commandType");
 class WindowSetRolloByWeatherStatusCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to set the desired position of the shutter of a window based on the weather status
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source, reason = '') {
         super(source, reason);
-        this._commandType = commandType_1.CommandType.WindowSetRolloByWeatherStatusCommand;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.WindowSetRolloByWeatherStatusCommand;
     }
 }
 exports.WindowSetRolloByWeatherStatusCommand = WindowSetRolloByWeatherStatusCommand;

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

@@ -3,11 +3,26 @@ import { CommandSource } from './commandSource';
 import { CommandType } from './commandType';
 import { ActuatorToggleCommand } from './actuatorToggleCommand';
 import { iActuator } from '../../server';
+import { BlockAutomaticCommand } from './blockAutomaticCommand';
 export declare class ActuatorSetStateCommand extends BaseCommand {
     readonly on: boolean;
-    timeout: number;
-    _commandType: CommandType;
-    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, timeout?: number);
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * The command to disable automatic actions for a specific duration.
+     * Null = no automatic actions will be disabled.
+     * Undefined = use device or global default
+     */
+    disableAutomaticCommand: BlockAutomaticCommand | null | undefined;
+    /**
+     * Command to set the state of an actuator
+     * @param source - The source of the command
+     * @param on - The new state of the actuator
+     * @param reason - You can provide a reason for clarification
+     * @param disableAutomatic - If provided, the device will remain in the desired state for the given disable action.
+     * If unset the default value in accordance to settings will be used
+     */
+    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, disableAutomatic?: BlockAutomaticCommand | null);
     get logMessage(): string;
     static byActuatorAndToggleCommand(device: iActuator, c: ActuatorToggleCommand): ActuatorSetStateCommand;
 }

package/lib/models/command/actuatorSetStateCommand.js

@@ -4,19 +4,28 @@ exports.ActuatorSetStateCommand = void 0;
 const baseCommand_1 = require("./baseCommand");
 const commandType_1 = require("./commandType");
 class ActuatorSetStateCommand extends baseCommand_1.BaseCommand {
-    constructor(source, on, reason = '', timeout = -1) {
+    /**
+     * Command to set the state of an actuator
+     * @param source - The source of the command
+     * @param on - The new state of the actuator
+     * @param reason - You can provide a reason for clarification
+     * @param disableAutomatic - If provided, the device will remain in the desired state for the given disable action.
+     * If unset the default value in accordance to settings will be used
+     */
+    constructor(source, on, reason = '', disableAutomatic) {
         super(source, reason);
         this.on = on;
-        this.timeout = timeout;
-        this._commandType = commandType_1.CommandType.ShutterSetLevelCommand;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.ActuatorSetStateCommand;
+        this.disableAutomaticCommand = disableAutomatic;
     }
     get logMessage() {
-        return `Actuator setState to ${this.on} for reason: ${this.reasonTrace}`;
+        var _a;
+        return `Actuator setState to ${this.on} with disableCommand ${(_a = this.disableAutomaticCommand) === null || _a === void 0 ? void 0 : _a.logMessage} for reason: ${this.reasonTrace}`;
     }
     static byActuatorAndToggleCommand(device, c) {
         const newVal = device.queuedValue !== null ? !device.queuedValue : !device.actuatorOn;
-        const timeout = newVal && c.isForceAction ? 30 * 60 * 1000 : -1;
-        return new ActuatorSetStateCommand(c, newVal, 'Due to ActuatorToggle', timeout);
+        return new ActuatorSetStateCommand(c, newVal, 'Due to ActuatorToggle', c.isForceAction ? undefined : null);
     }
 }
 exports.ActuatorSetStateCommand = ActuatorSetStateCommand;

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

@@ -2,7 +2,12 @@ import { CommandType } from './commandType';
 import { BaseCommand } from './baseCommand';
 import { CommandSource } from './commandSource';
 export declare class ActuatorToggleCommand extends BaseCommand {
-    _commandType: CommandType;
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Command to toggle the state of an actuator
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source: CommandSource | BaseCommand, reason?: string);
-    get logMessage(): string;
 }

package/lib/models/command/actuatorToggleCommand.js

@@ -4,12 +4,15 @@ exports.ActuatorToggleCommand = void 0;
 const commandType_1 = require("./commandType");
 const baseCommand_1 = require("./baseCommand");
 class ActuatorToggleCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to toggle the state of an actuator
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source, reason = '') {
         super(source, reason);
-        this._commandType = commandType_1.CommandType.ActuatorToggleCommand;
-    }
-    get logMessage() {
-        return `Actuator toggle for reason: ${this.reasonTrace}`;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.ActuatorToggleCommand;
     }
 }
 exports.ActuatorToggleCommand = ActuatorToggleCommand;

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

@@ -3,7 +3,14 @@ import { CommandType } from './commandType';
 import { CommandSource } from './commandSource';
 export declare class ActuatorWriteStateToDeviceCommand extends BaseCommand {
     readonly stateValue: boolean;
-    _commandType: CommandType;
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Command to write the state of an actuator to the device
+     * @param source - The source of the command
+     * @param stateValue - The new state of the actuator
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source: CommandSource | BaseCommand, stateValue: boolean, reason?: string);
     get logMessage(): string;
 }

package/lib/models/command/actuatorWriteStateToDeviceCommand.js

@@ -3,13 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActuatorWriteStateToDeviceCommand = void 0;
 const baseCommand_1 = require("./baseCommand");
 const commandType_1 = require("./commandType");
+const actuatorSetStateCommand_1 = require("./actuatorSetStateCommand");
 class ActuatorWriteStateToDeviceCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to write the state of an actuator to the device
+     * @param source - The source of the command
+     * @param stateValue - The new state of the actuator
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source, stateValue, reason = '') {
         super(source, reason);
         this.stateValue = stateValue;
-        this._commandType = commandType_1.CommandType.ActuatorWriteStateToDeviceCommand;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.ActuatorWriteStateToDeviceCommand;
     }
     get logMessage() {
+        if (this.source instanceof actuatorSetStateCommand_1.ActuatorSetStateCommand) {
+            return `Actuator Write StateToDevice original Log-message: ${this.source.logMessage}`;
+        }
         return `Actuator writeStateToDevice(${this.stateValue}) for reason: ${this.reasonTrace}`;
     }
 }

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

@@ -3,10 +3,31 @@ import { CommandType } from './commandType';
 export declare abstract class BaseCommand {
     readonly source: CommandSource | BaseCommand;
     readonly reason: string;
+    /**
+     * The timestamp of the command being created
+     */
     readonly timestamp: Date;
-    abstract _commandType: CommandType;
-    constructor(source?: CommandSource | BaseCommand, reason?: string);
+    /**
+     * The type of this command to be used for comparison.
+     *
+     * For checking if any command in the stack is of a specific type, use the {@link containsType} method.
+     */
+    abstract type: CommandType;
+    /**
+     * If set, this will be used in regards to checking if this is a force/manual/automatic action.
+     * @type {CommandSource | undefined} The source of the command
+     */
+    overrideCommandSource: CommandSource | undefined;
+    /**
+     * Base class for all commands
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
+    protected constructor(source?: CommandSource | BaseCommand, reason?: string);
+    get isAutomaticAction(): boolean;
     get isForceAction(): boolean;
+    get isManual(): boolean;
     get isInitial(): boolean;
     get reasonTrace(): string;
+    containsType(type: CommandType): boolean;
 }

package/lib/models/command/baseCommand.js

@@ -3,29 +3,69 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCommand = void 0;
 const commandSource_1 = require("./commandSource");
 class BaseCommand {
+    /**
+     * Base class for all commands
+     * @param source - The source of the command
+     * @param reason - You can provide a reason for clarification
+     */
     constructor(source = commandSource_1.CommandSource.Unknown, reason = '') {
         this.source = source;
         this.reason = reason;
         this.timestamp = new Date();
     }
+    get isAutomaticAction() {
+        if (this.overrideCommandSource !== undefined) {
+            return this.overrideCommandSource === commandSource_1.CommandSource.Automatic;
+        }
+        if (this.source instanceof BaseCommand) {
+            return this.source.isAutomaticAction;
+        }
+        return this.source === commandSource_1.CommandSource.Automatic;
+    }
     get isForceAction() {
+        if (this.overrideCommandSource !== undefined) {
+            return (this.overrideCommandSource === commandSource_1.CommandSource.Manual ||
+                this.overrideCommandSource === commandSource_1.CommandSource.API ||
+                this.overrideCommandSource === commandSource_1.CommandSource.Force);
+        }
         if (this.source instanceof BaseCommand) {
             return this.source.isForceAction;
         }
         return (this.source === commandSource_1.CommandSource.Manual || this.source === commandSource_1.CommandSource.API || this.source === commandSource_1.CommandSource.Force);
     }
+    get isManual() {
+        if (this.overrideCommandSource !== undefined) {
+            return this.overrideCommandSource === commandSource_1.CommandSource.Manual || this.overrideCommandSource === commandSource_1.CommandSource.API;
+        }
+        if (this.source instanceof BaseCommand) {
+            return this.source.isManual;
+        }
+        return this.source === commandSource_1.CommandSource.Manual || this.source === commandSource_1.CommandSource.API;
+    }
     get isInitial() {
+        if (this.overrideCommandSource !== undefined) {
+            return this.overrideCommandSource === commandSource_1.CommandSource.Initial;
+        }
         if (this.source instanceof BaseCommand) {
             return this.source.isInitial;
         }
         return this.source === commandSource_1.CommandSource.Initial;
     }
     get reasonTrace() {
-        const ownPart = this.reason !== '' ? `${this._commandType}("${this.reason}")` : `${this._commandType}`;
+        const ownPart = this.reason !== '' ? `${this.type}("${this.reason}")` : `${this.type}`;
         if (typeof this.source === 'object') {
             return `${this.source.reasonTrace} -> ${ownPart}`;
         }
         return `CommandType("${commandSource_1.CommandSource[this.source]}") stack => ${ownPart}`;
     }
+    containsType(type) {
+        if (this.type === type) {
+            return true;
+        }
+        if (this.source instanceof BaseCommand) {
+            return this.source.containsType(type);
+        }
+        return false;
+    }
 }
 exports.BaseCommand = BaseCommand;

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

@@ -0,0 +1,32 @@
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { CollisionSolving } from '../collisionSolving';
+import { BaseCommand } from './baseCommand';
+import { DeviceSettings } from '../deviceSettings';
+export declare class BlockAutomaticCommand extends BaseCommand {
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Whether the device should revert to automatic afterward.
+     */
+    readonly revertToAutomaticAtBlockLift: boolean;
+    /**
+     * The duration in milliseconds for the automatic actions to be disabled.
+     */
+    readonly durationMS: number;
+    /**
+     * The action to take if a block is already active.
+     */
+    readonly onCollideAction: CollisionSolving;
+    /**
+     * Command to disable automatic actions for a specific duration.
+     * @param source - The source of the command.
+     * @param durationMS - The duration in milliseconds for the automatic actions to be disabled --> If unset the default value will be used {@link SettingsService.settings.blockAutomaticHandlerDefaults.blockAutomaticDurationMS}
+     * @param reason - You can provide an individual reason here for debugging purpose.
+     * @param onCollideAction - The action to take if a block is already active. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.defaultCollisionSolving}
+     * @param revertToAutomaticAtBlockLift - Whether the device should revert to automatic afterward. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.revertToAutomaticAtBlockLift}
+     */
+    constructor(source: CommandSource | BaseCommand, durationMS?: number, reason?: string, onCollideAction?: CollisionSolving, revertToAutomaticAtBlockLift?: boolean);
+    get logMessage(): string;
+    static fromDeviceSettings(c: BaseCommand, deviceSettings: DeviceSettings): BlockAutomaticCommand | null;
+}

package/lib/models/command/blockAutomaticCommand.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAutomaticCommand = void 0;
+const commandType_1 = require("./commandType");
+const collisionSolving_1 = require("../collisionSolving");
+const baseCommand_1 = require("./baseCommand");
+const server_1 = require("../../server");
+class BlockAutomaticCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to disable automatic actions for a specific duration.
+     * @param source - The source of the command.
+     * @param durationMS - The duration in milliseconds for the automatic actions to be disabled --> If unset the default value will be used {@link SettingsService.settings.blockAutomaticHandlerDefaults.blockAutomaticDurationMS}
+     * @param reason - You can provide an individual reason here for debugging purpose.
+     * @param onCollideAction - The action to take if a block is already active. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.defaultCollisionSolving}
+     * @param revertToAutomaticAtBlockLift - Whether the device should revert to automatic afterward. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.revertToAutomaticAtBlockLift}
+     */
+    constructor(source, durationMS, reason = '', onCollideAction, revertToAutomaticAtBlockLift) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        super(source, reason);
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.BlockAutomaticCommand;
+        this.durationMS =
+            (_c = durationMS !== null && durationMS !== void 0 ? durationMS : (_b = (_a = server_1.SettingsService.settings) === null || _a === void 0 ? void 0 : _a.blockAutomaticHandlerDefaults) === null || _b === void 0 ? void 0 : _b.blockAutomaticDurationMS) !== null && _c !== void 0 ? _c : 30 * 60 * 1000;
+        this.revertToAutomaticAtBlockLift =
+            (_f = revertToAutomaticAtBlockLift !== null && revertToAutomaticAtBlockLift !== void 0 ? revertToAutomaticAtBlockLift : (_e = (_d = server_1.SettingsService.settings) === null || _d === void 0 ? void 0 : _d.blockAutomaticHandlerDefaults) === null || _e === void 0 ? void 0 : _e.revertToAutomaticAtBlockLift) !== null && _f !== void 0 ? _f : true;
+        this.onCollideAction =
+            (_j = onCollideAction !== null && onCollideAction !== void 0 ? onCollideAction : (_h = (_g = server_1.SettingsService.settings) === null || _g === void 0 ? void 0 : _g.blockAutomaticHandlerDefaults) === null || _h === void 0 ? void 0 : _h.defaultCollisionSolving) !== null && _j !== void 0 ? _j : collisionSolving_1.CollisionSolving.overrideIfGreater;
+    }
+    get logMessage() {
+        return `BlockAutomatic for ${this.durationMS}ms with onCollideAction ${this.onCollideAction} for reason: ${this.reasonTrace}`;
+    }
+    static fromDeviceSettings(c, deviceSettings) {
+        var _a, _b, _c, _d;
+        if ((_a = deviceSettings.blockAutomaticSettings) === null || _a === void 0 ? void 0 : _a.dontBlockAutomaticIfNotProvided) {
+            return null;
+        }
+        return new BlockAutomaticCommand(c, (_b = deviceSettings.blockAutomaticSettings) === null || _b === void 0 ? void 0 : _b.blockAutomaticDurationMS, '', (_c = deviceSettings.blockAutomaticSettings) === null || _c === void 0 ? void 0 : _c.defaultCollisionSolving, (_d = deviceSettings.blockAutomaticSettings) === null || _d === void 0 ? void 0 : _d.revertToAutomaticAtBlockLift);
+    }
+}
+exports.BlockAutomaticCommand = BlockAutomaticCommand;

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

@@ -0,0 +1,18 @@
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { BaseCommand } from './baseCommand';
+export declare class BlockAutomaticLiftBlockCommand extends BaseCommand {
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Whether the device should revert to desired automatic value.
+     */
+    readonly revertToAutomatic: boolean;
+    /**
+     * Command to lift a block --> Restore the automatic actions.
+     * @param source - The source of the command.
+     * @param reason - You can provide an individual reason here for debugging purpose.
+     * @param revertToAutomatic - Whether the device should revert to automatic afterward. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.revertToAutomaticAtBlockLift}
+     */
+    constructor(source: CommandSource | BaseCommand, reason?: string, revertToAutomatic?: boolean);
+}

package/lib/models/command/blockAutomaticLiftBlockCommand.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAutomaticLiftBlockCommand = void 0;
+const commandType_1 = require("./commandType");
+const baseCommand_1 = require("./baseCommand");
+const server_1 = require("../../server");
+class BlockAutomaticLiftBlockCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to lift a block --> Restore the automatic actions.
+     * @param source - The source of the command.
+     * @param reason - You can provide an individual reason here for debugging purpose.
+     * @param revertToAutomatic - Whether the device should revert to automatic afterward. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.revertToAutomaticAtBlockLift}
+     */
+    constructor(source, reason = '', revertToAutomatic) {
+        var _a, _b, _c;
+        super(source, reason);
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.BlockAutomaticLiftBlockCommand;
+        this.revertToAutomatic =
+            (_c = revertToAutomatic !== null && revertToAutomatic !== void 0 ? revertToAutomatic : (_b = (_a = server_1.SettingsService.settings) === null || _a === void 0 ? void 0 : _a.blockAutomaticHandlerDefaults) === null || _b === void 0 ? void 0 : _b.revertToAutomaticAtBlockLift) !== null && _c !== void 0 ? _c : true;
+    }
+}
+exports.BlockAutomaticLiftBlockCommand = BlockAutomaticLiftBlockCommand;

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

@@ -0,0 +1,27 @@
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { CollisionSolving } from '../collisionSolving';
+import { BaseCommand } from './baseCommand';
+export declare class BlockAutomaticUntilCommand extends BaseCommand {
+    targetDate: Date;
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * The action to take if a block is already active.
+     */
+    readonly onCollideAction: CollisionSolving;
+    /**
+     * Whether the device should revert to automatic afterward.
+     */
+    readonly revertToAutomaticAtBlockLift: boolean;
+    /**
+     * Command to disable automatic actions until a specific date.
+     * @param source - The source of the command.
+     * @param targetDate - The date until the automatic actions will be disabled.
+     * @param reason - You can provide an individual reason here for debugging purpose.
+     * @param onCollideAction - The action to take if a block is already active. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.defaultCollisionSolving}
+     * @param revertToAutomaticAtBlockLift - Whether the device should revert to automatic afterward. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.revertToAutomaticAtBlockLift}
+     */
+    constructor(source: CommandSource | BaseCommand, targetDate: Date, reason?: string, onCollideAction?: CollisionSolving, revertToAutomaticAtBlockLift?: boolean);
+    get logMessage(): string;
+}

package/lib/models/command/blockAutomaticUntilCommand.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAutomaticUntilCommand = void 0;
+const commandType_1 = require("./commandType");
+const collisionSolving_1 = require("../collisionSolving");
+const baseCommand_1 = require("./baseCommand");
+const server_1 = require("../../server");
+class BlockAutomaticUntilCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to disable automatic actions until a specific date.
+     * @param source - The source of the command.
+     * @param targetDate - The date until the automatic actions will be disabled.
+     * @param reason - You can provide an individual reason here for debugging purpose.
+     * @param onCollideAction - The action to take if a block is already active. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.defaultCollisionSolving}
+     * @param revertToAutomaticAtBlockLift - Whether the device should revert to automatic afterward. --> Default: {@link SettingsService.settings.blockAutomaticHandlerDefaults.revertToAutomaticAtBlockLift}
+     */
+    constructor(source, targetDate, reason = '', onCollideAction, revertToAutomaticAtBlockLift) {
+        var _a, _b, _c, _d, _e, _f;
+        super(source, reason);
+        this.targetDate = targetDate;
+        /** @inheritDoc */
+        this.type = commandType_1.CommandType.BlockAutomaticUntilCommand;
+        this.onCollideAction =
+            (_c = onCollideAction !== null && onCollideAction !== void 0 ? onCollideAction : (_b = (_a = server_1.SettingsService.settings) === null || _a === void 0 ? void 0 : _a.blockAutomaticHandlerDefaults) === null || _b === void 0 ? void 0 : _b.defaultCollisionSolving) !== null && _c !== void 0 ? _c : collisionSolving_1.CollisionSolving.overrideIfGreater;
+        this.revertToAutomaticAtBlockLift =
+            (_f = revertToAutomaticAtBlockLift !== null && revertToAutomaticAtBlockLift !== void 0 ? revertToAutomaticAtBlockLift : (_e = (_d = server_1.SettingsService.settings) === null || _d === void 0 ? void 0 : _d.blockAutomaticHandlerDefaults) === null || _e === void 0 ? void 0 : _e.revertToAutomaticAtBlockLift) !== null && _f !== void 0 ? _f : true;
+    }
+    get logMessage() {
+        return `Block automatic until ${this.targetDate.toLocaleString('de-DE')}, reason: ${this.reasonTrace}`;
+    }
+}
+exports.BlockAutomaticUntilCommand = BlockAutomaticUntilCommand;

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

@@ -1,8 +1,27 @@
 export declare enum CommandSource {
+    /**
+     * In case of unclear command stack/source this should be used.
+     */
     Unknown = 0,
+    /**
+     * This should mark all startup commands, as this allows devices to treat this correctly.
+     */
     Initial = 1,
+    /**
+     * This should mark all commands that are executed as an automatic response to a certain action/change.
+     */
     Automatic = 2,
+    /**
+     * This should mark all commands that are executed by a user thus having a higher priority than other automatic commands.
+     */
     Manual = 3,
+    /**
+     * This should mark all commands that are executed by an API call.
+     * !WARNING! API could be an automatic call, but also a manual call e.g. using hoffmation-ios or homebridge-hoffmation --> So this is a higher priority than Automatic but still lower than manual/force.
+     */
     API = 4,
+    /**
+     * This should mark all commands that have highest priority, thus overruling/ignoring certain controls/safety mechanisms.
+     */
     Force = 5
 }

package/lib/models/command/commandSource.js

@@ -1,12 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandSource = void 0;
+// Definition: Enum for command source.
 var CommandSource;
 (function (CommandSource) {
+    /**
+     * In case of unclear command stack/source this should be used.
+     */
     CommandSource[CommandSource["Unknown"] = 0] = "Unknown";
+    /**
+     * This should mark all startup commands, as this allows devices to treat this correctly.
+     */
     CommandSource[CommandSource["Initial"] = 1] = "Initial";
+    /**
+     * This should mark all commands that are executed as an automatic response to a certain action/change.
+     */
     CommandSource[CommandSource["Automatic"] = 2] = "Automatic";
+    /**
+     * This should mark all commands that are executed by a user thus having a higher priority than other automatic commands.
+     */
     CommandSource[CommandSource["Manual"] = 3] = "Manual";
+    /**
+     * This should mark all commands that are executed by an API call.
+     * !WARNING! API could be an automatic call, but also a manual call e.g. using hoffmation-ios or homebridge-hoffmation --> So this is a higher priority than Automatic but still lower than manual/force.
+     */
     CommandSource[CommandSource["API"] = 4] = "API";
+    /**
+     * This should mark all commands that have highest priority, thus overruling/ignoring certain controls/safety mechanisms.
+     */
     CommandSource[CommandSource["Force"] = 5] = "Force";
 })(CommandSource || (exports.CommandSource = CommandSource = {}));

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

@@ -1,21 +1,32 @@
 export declare enum CommandType {
+    BatteryManagerLevelChangeAction = "BatteryManagerLevelChangeAction",
+    BlockAutomaticLiftBlockCommand = "BlockAutomaticLiftBlockCommand",
+    BlockAutomaticCommand = "BlockAutomaticCommand",
+    BlockAutomaticUntilCommand = "BlockAutomaticUntilCommand",
     ActuatorToggleCommand = "ActuatorToggleCommand",
     ActuatorSetStateCommand = "ActuatorSetStateCommand",
     ActuatorRestoreTargetAutomaticValueCommand = "ActuatorRestoreTargetAutomaticValueCommand",
     ActuatorWriteStateToDeviceCommand = "ActuatorWriteStateToDeviceCommand",
     DimmerSetLightCommand = "DimmerSetLightCommand",
     FloorSetAllShuttersCommand = "FloorSetAllShuttersCommand",
+    HumiditySensorChangeAction = "HumiditySensorChangeAction",
     LampSetLightCommand = "LampSetLightCommand",
     LampSetTimeBasedCommand = "LampSetTimeBasedCommand",
     LampToggleLightCommand = "LampToggleLightCommand",
     LedSetLightCommand = "LedSetLightCommand",
     LightGroupSwitchTimeConditional = "LightGroupSwitchTimeConditional",
+    MotionSensorAction = "MotionSensorAction",
+    PresenceGroupAnyMovementAction = "PresenceGroupAnyMovementAction",
+    PresenceGroupFirstEnterAction = "PresenceGroupFirstEnterAction",
+    PresenceGroupLastLeftAction = "PresenceGroupLastLeftAction",
     RoomRestoreShutterPositionCommand = "RoomRestoreShutterPositionCommand",
     RoomRestoreLightCommand = "RoomRestoreLightCommand",
     RoomSetLightTimeBasedCommand = "RoomSetLightTimeBasedCommand",
+    ShutterPositionChangedAction = "ShutterPositionChangedAction",
     ShutterSetLevelCommand = "ShutterSetLevelCommand",
     ShutterSunriseUpCommand = "ShutterSunriseUpCommand",
     SunsetDownCommand = "SunsetDownCommand",
+    TemperatureSensorChangeAction = "TemperatureSensorChangeAction",
     WindowRestoreDesiredPositionCommand = "WindowRestoreDesiredPositionCommand",
     WindowSetDesiredPositionCommand = "WindowSetDesiredPositionCommand",
     WindowSetRolloByWeatherStatusCommand = "WindowSetRolloByWeatherStatusCommand",

package/lib/models/command/commandType.js

@@ -3,23 +3,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandType = void 0;
 var CommandType;
 (function (CommandType) {
+    CommandType["BatteryManagerLevelChangeAction"] = "BatteryManagerLevelChangeAction";
+    CommandType["BlockAutomaticLiftBlockCommand"] = "BlockAutomaticLiftBlockCommand";
+    CommandType["BlockAutomaticCommand"] = "BlockAutomaticCommand";
+    CommandType["BlockAutomaticUntilCommand"] = "BlockAutomaticUntilCommand";
     CommandType["ActuatorToggleCommand"] = "ActuatorToggleCommand";
     CommandType["ActuatorSetStateCommand"] = "ActuatorSetStateCommand";
     CommandType["ActuatorRestoreTargetAutomaticValueCommand"] = "ActuatorRestoreTargetAutomaticValueCommand";
     CommandType["ActuatorWriteStateToDeviceCommand"] = "ActuatorWriteStateToDeviceCommand";
     CommandType["DimmerSetLightCommand"] = "DimmerSetLightCommand";
     CommandType["FloorSetAllShuttersCommand"] = "FloorSetAllShuttersCommand";
+    CommandType["HumiditySensorChangeAction"] = "HumiditySensorChangeAction";
     CommandType["LampSetLightCommand"] = "LampSetLightCommand";
     CommandType["LampSetTimeBasedCommand"] = "LampSetTimeBasedCommand";
     CommandType["LampToggleLightCommand"] = "LampToggleLightCommand";
     CommandType["LedSetLightCommand"] = "LedSetLightCommand";
     CommandType["LightGroupSwitchTimeConditional"] = "LightGroupSwitchTimeConditional";
+    CommandType["MotionSensorAction"] = "MotionSensorAction";
+    CommandType["PresenceGroupAnyMovementAction"] = "PresenceGroupAnyMovementAction";
+    CommandType["PresenceGroupFirstEnterAction"] = "PresenceGroupFirstEnterAction";
+    CommandType["PresenceGroupLastLeftAction"] = "PresenceGroupLastLeftAction";
     CommandType["RoomRestoreShutterPositionCommand"] = "RoomRestoreShutterPositionCommand";
     CommandType["RoomRestoreLightCommand"] = "RoomRestoreLightCommand";
     CommandType["RoomSetLightTimeBasedCommand"] = "RoomSetLightTimeBasedCommand";
+    CommandType["ShutterPositionChangedAction"] = "ShutterPositionChangedAction";
     CommandType["ShutterSetLevelCommand"] = "ShutterSetLevelCommand";
     CommandType["ShutterSunriseUpCommand"] = "ShutterSunriseUpCommand";
     CommandType["SunsetDownCommand"] = "SunsetDownCommand";
+    CommandType["TemperatureSensorChangeAction"] = "TemperatureSensorChangeAction";
     CommandType["WindowRestoreDesiredPositionCommand"] = "WindowRestoreDesiredPositionCommand";
     CommandType["WindowSetDesiredPositionCommand"] = "WindowSetDesiredPositionCommand";
     CommandType["WindowSetRolloByWeatherStatusCommand"] = "WindowSetRolloByWeatherStatusCommand";