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

package/lib/index.d.ts

@@ -8,9 +8,13 @@ export declare class HoffmationInitializationObject {
     constructor(config: iConfig);
 }
 export declare class HoffmationBase {
+    /**
+     * The iobroker Instance to interact with an ioBroker server
+     * @deprecated To ensure Hoffmation being capable of running without ioBroker, this property will be removed in the future.
+     */
     static ioMain: ioBrokerMain;
     static initializeBeforeIoBroker(initObject: HoffmationInitializationObject): Promise<void>;
     static initializePostRoomCreationBeforeIoBroker(): void;
     static initializePostIoBroker(defaultMuellSonos?: iSpeaker): void;
-    static startIoBroker(devices: Devices): void;
+    static startIoBroker(_devices: Devices): void;
 }

package/lib/index.js

@@ -36,7 +36,7 @@ class HoffmationBase {
         if (initObject.config.logSettings) {
             server_1.ServerLogService.initialize(initObject.config.logSettings);
         }
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base Startup`);
+        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Startup');
         if (initObject.config.persistence) {
             if (initObject.config.persistence.postgreSql) {
                 server_1.Utils.dbo = new server_1.PostgreSqlPersist(initObject.config.persistence.postgreSql);
@@ -44,39 +44,39 @@ class HoffmationBase {
             await ((_a = server_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.initialize());
         }
         if (server_1.SettingsService.settings.mp3Server) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Mp3Server settings detected --> initializing`);
+            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Mp3Server settings detected --> initializing');
             new server_1.MP3Server(server_1.SettingsService.settings.mp3Server);
         }
         if (server_1.SettingsService.settings.telegram) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Telegram settings detected --> initializing`);
+            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Telegram settings detected --> initializing');
             server_1.TelegramService.initialize(server_1.SettingsService.settings.telegram);
         }
         if (server_1.SettingsService.settings.tibber) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Tibber settings detected --> initializing`);
+            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Tibber settings detected --> initializing');
             server_1.TibberService.initialize(server_1.SettingsService.settings.tibber);
         }
         if (server_1.SettingsService.settings.polly) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Amazon Polly settings detected --> initializing`);
+            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Amazon Polly settings detected --> initializing');
             server_1.PollyService.initialize(server_1.SettingsService.settings.polly);
         }
         if (server_1.SettingsService.settings.asusConfig) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Asus Router settings detected --> initializing`);
+            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Asus Router settings detected --> initializing');
             new server_1.AsusRouter(server_1.SettingsService.settings.asusConfig);
         }
         else if (server_1.SettingsService.settings.unifiSettings) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Unifi Router settings detected --> initializing`);
+            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Unifi Router settings detected --> initializing');
             new server_1.UnifiRouter(server_1.SettingsService.settings.unifiSettings);
         }
         server_1.TimeCallbackService.init();
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base First Initializations finished`);
+        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base First Initializations finished');
     }
     static initializePostRoomCreationBeforeIoBroker() {
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base Post Room Creation`);
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base Post Room Creation finished`);
+        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Post Room Creation');
+        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Post Room Creation finished');
     }
     static initializePostIoBroker(defaultMuellSonos) {
         var _a, _b;
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base Post ioBrokerInitializations`);
+        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Post ioBrokerInitializations');
         server_1.Trilateration.initialize();
         if (server_1.SettingsService.TelegramActive)
             server_1.TelegramCommands.initialize();
@@ -97,34 +97,34 @@ class HoffmationBase {
         }
         server_1.Utils.guardedNewThread(() => {
             if (server_1.SettingsService.settings.muell) {
-                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Muell settings detected --> initializing`);
+                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Muell settings detected --> initializing');
                 server_1.MuellService.intialize(server_1.SettingsService.settings.muell, defaultMuellSonos);
             }
         });
         server_1.Utils.guardedNewThread(() => {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `News settings detected --> initializing`);
+            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'News settings detected --> initializing');
             server_1.NewsService.initialize(server_1.SettingsService.settings.news);
         });
         server_1.Utils.guardedNewThread(() => {
             if (server_1.SettingsService.settings.weather) {
-                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Weather settings detected --> initializing`);
+                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Weather settings detected --> initializing');
                 server_1.WeatherService.initialize(server_1.SettingsService.settings.weather);
             }
         });
         server_1.Utils.guardedNewThread(() => {
             if (server_1.SettingsService.settings.victron) {
-                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Victron settings detected --> initializing`);
+                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Victron settings detected --> initializing');
                 server_1.VictronService.initialize(server_1.SettingsService.settings.victron);
             }
         });
         if (server_1.SettingsService.TelegramActive)
             server_1.TelegramService.publishCommands();
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base Post ioBrokerInitializations finished`);
+        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Post ioBrokerInitializations finished');
     }
-    static startIoBroker(devices) {
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base: Starting ioBroker Connection`);
-        this.ioMain = new server_1.ioBrokerMain(new server_1.DeviceUpdater(devices));
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base: ioBroker Connection established`);
+    static startIoBroker(_devices) {
+        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base: Starting ioBroker Connection');
+        this.ioMain = new server_1.ioBrokerMain(new server_1.DeviceUpdater());
+        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base: ioBroker Connection established');
     }
 }
 exports.HoffmationBase = HoffmationBase;

package/lib/liquid-pid.d.ts

@@ -4,12 +4,9 @@
  *
  * I'm a NodeJS guy not a scientist, so please be a careful!!!
  * FYI: http://en.wikipedia.org/wiki/PID_controller
- *
- * @module controller
- *
  * @author https://github.com/hekike/liquid-pid
- * @licence MIT
- **/
+ * licence: MIT
+ */
 export declare class PIDController {
     private _Tref;
     private readonly _Pmax;

package/lib/liquid-pid.js

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PIDController = void 0;
+/* eslint-disable jsdoc/require-jsdoc */
 /**
  * !!Ported from liquid pid!!!!
  * Control the PWM relays from the temperature
  *
  * I'm a NodeJS guy not a scientist, so please be a careful!!!
  * FYI: http://en.wikipedia.org/wiki/PID_controller
- *
- * @module controller
- *
  * @author https://github.com/hekike/liquid-pid
- * @licence MIT
- **/
+ * licence: MIT
+ */
 class PIDController {
     constructor(options) {
         var _a, _b, _c, _d, _f, _g;

package/lib/models/blockAutomaticSettings.d.ts

@@ -0,0 +1,23 @@
+import { CollisionSolving } from './collisionSolving';
+export declare class BlockAutomaticSettings {
+    /**
+     * The duration in ms at which the automatic block should be disabled on force actions.
+     * If not set {@link iBlockAutomaticHandlerDefaults.blockAutomaticDurationMS} will be used.
+     */
+    blockAutomaticDurationMS?: number;
+    /**
+     * If set to true, the automatic won't be blocked on force Action (unless explicitly provided).
+     */
+    dontBlockAutomaticIfNotProvided?: boolean;
+    /**
+     * The collision solving strategy to use
+     * If not set {@link iBlockAutomaticHandlerDefaults.defaultCollisionSolving} will be used.
+     */
+    defaultCollisionSolving?: CollisionSolving;
+    /**
+     * If set to true, the automatic will be reverted to the automatic state when the block is lifted.
+     * If not set {@link iBlockAutomaticHandlerDefaults.revertToAutomaticAtBlockLift} will be used.
+     */
+    revertToAutomaticAtBlockLift?: boolean;
+    fromPartialObject(obj: Partial<BlockAutomaticSettings>): void;
+}

package/lib/models/blockAutomaticSettings.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAutomaticSettings = void 0;
+class BlockAutomaticSettings {
+    constructor() {
+        /**
+         * If set to true, the automatic won't be blocked on force Action (unless explicitly provided).
+         */
+        this.dontBlockAutomaticIfNotProvided = false;
+    }
+    fromPartialObject(obj) {
+        var _a, _b, _c, _d;
+        this.blockAutomaticDurationMS = (_a = obj.blockAutomaticDurationMS) !== null && _a !== void 0 ? _a : this.blockAutomaticDurationMS;
+        this.dontBlockAutomaticIfNotProvided = (_b = obj.dontBlockAutomaticIfNotProvided) !== null && _b !== void 0 ? _b : this.dontBlockAutomaticIfNotProvided;
+        this.defaultCollisionSolving = (_c = obj.defaultCollisionSolving) !== null && _c !== void 0 ? _c : this.defaultCollisionSolving;
+        this.revertToAutomaticAtBlockLift = (_d = obj.revertToAutomaticAtBlockLift) !== null && _d !== void 0 ? _d : this.revertToAutomaticAtBlockLift;
+    }
+}
+exports.BlockAutomaticSettings = BlockAutomaticSettings;

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

@@ -4,7 +4,15 @@ import { CommandType } from './commandType';
 export declare class ShutterSetLevelCommand extends BaseCommand {
     readonly level: number;
     readonly skipOpenWarning: boolean;
+    /** @inheritDoc */
     _commandType: CommandType;
+    /**
+     * Command to set the level of a shutter
+     * @param source - The source of the command
+     * @param level - The level to set the shutter to (0: close, 100: completely open)
+     * @param reason - You can provide a reason for clarification
+     * @param skipOpenWarning - Whether to skip the warning of window being open
+     */
     constructor(source: CommandSource | BaseCommand, level: number, reason?: string, skipOpenWarning?: boolean);
     get logMessage(): string;
 }

package/lib/models/command/ShutterSetLevelCommand.js

@@ -4,14 +4,22 @@ exports.ShutterSetLevelCommand = void 0;
 const baseCommand_1 = require("./baseCommand");
 const commandType_1 = require("./commandType");
 class ShutterSetLevelCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Command to set the level of a shutter
+     * @param source - The source of the command
+     * @param level - The level to set the shutter to (0: close, 100: completely open)
+     * @param reason - You can provide a reason for clarification
+     * @param skipOpenWarning - Whether to skip the warning of window being open
+     */
     constructor(source, level, reason = '', skipOpenWarning = false) {
         super(source, reason);
         this.level = level;
         this.skipOpenWarning = skipOpenWarning;
+        /** @inheritDoc */
         this._commandType = commandType_1.CommandType.ShutterSetLevelCommand;
     }
     get logMessage() {
-        return `Shutter setLevel to ${this.level} from ${this.source} for reason: ${this.reasonTrace}`;
+        return `Shutter setLevel to ${this.level} for reason: ${this.reasonTrace}`;
     }
 }
 exports.ShutterSetLevelCommand = ShutterSetLevelCommand;

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

@@ -2,6 +2,12 @@ import { BaseCommand } from './baseCommand';
 import { CommandSource } from './commandSource';
 import { CommandType } from './commandType';
 export declare class WindowRestoreDesiredPositionCommand extends BaseCommand {
+    /** @inheritDoc */
     _commandType: CommandType;
+    /**
+     * Command to restore the desired position of the shutter of a window
+     * @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/WindowRestoreDesiredPositionCommand.js

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

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

@@ -3,6 +3,13 @@ import { CommandSource } from './commandSource';
 import { CommandType } from './commandType';
 export declare class WindowSetDesiredPositionCommand extends BaseCommand {
     readonly position: number;
+    /** @inheritDoc */
     _commandType: CommandType;
+    /**
+     * 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
+     */
     constructor(source: CommandSource | BaseCommand, position: number, reason?: string);
 }

package/lib/models/command/WindowSetDesiredPositionCommand.js

@@ -4,9 +4,16 @@ exports.WindowSetDesiredPositionCommand = void 0;
 const baseCommand_1 = require("./baseCommand");
 const commandType_1 = require("./commandType");
 class WindowSetDesiredPositionCommand extends baseCommand_1.BaseCommand {
+    /**
+     * 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
+     */
     constructor(source, position, reason = '') {
         super(source, reason);
         this.position = position;
+        /** @inheritDoc */
         this._commandType = commandType_1.CommandType.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 {
+    /** @inheritDoc */
     _commandType: 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,8 +4,14 @@ 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);
+        /** @inheritDoc */
         this._commandType = commandType_1.CommandType.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;
+    /** @inheritDoc */
     _commandType: CommandType;
-    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, timeout?: number);
+    /**
+     * 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._commandType = commandType_1.CommandType.ActuatorSetStateCommand;
+        this.disableAutomaticCommand = disableAutomatic;
     }
     get logMessage() {
-        return `Actuator setState to ${this.on} from ${this.source} 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 {
+    /** @inheritDoc */
     _commandType: 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);
+        /** @inheritDoc */
         this._commandType = commandType_1.CommandType.ActuatorToggleCommand;
     }
-    get logMessage() {
-        return `Actuator toggle due to ${this.source} for reason: ${this.reasonTrace}`;
-    }
 }
 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;
+    /** @inheritDoc */
     _commandType: CommandType;
-    constructor(stateValue: boolean, source: CommandSource | BaseCommand, reason?: string);
+    /**
+     * 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,14 +3,25 @@ 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 {
-    constructor(stateValue, source, reason = '') {
+    /**
+     * 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;
+        /** @inheritDoc */
         this._commandType = commandType_1.CommandType.ActuatorWriteStateToDeviceCommand;
     }
     get logMessage() {
-        return `Actuator writeStateToDevice(${this.stateValue}) due to ${this.source} for reason: ${this.reasonTrace}`;
+        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}`;
     }
 }
 exports.ActuatorWriteStateToDeviceCommand = ActuatorWriteStateToDeviceCommand;

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;
+    /**
+     * 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 _commandType: CommandType;
-    constructor(source?: CommandSource | BaseCommand, reason?: string);
+    /**
+     * 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,35 +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() {
-        let reason = '';
-        if (this.source instanceof BaseCommand) {
-            reason = this.source.reasonTrace;
+        const ownPart = this.reason !== '' ? `${this._commandType}("${this.reason}")` : `${this._commandType}`;
+        if (typeof this.source === 'object') {
+            return `${this.source.reasonTrace} -> ${ownPart}`;
         }
-        if (this.reason === '') {
-            if (reason === '') {
-                return `${this._commandType}`;
-            }
-            return `${reason} -> ${this._commandType}`;
+        return `CommandType("${commandSource_1.CommandSource[this.source]}") stack => ${ownPart}`;
+    }
+    containsType(type) {
+        if (this._commandType === type) {
+            return true;
+        }
+        if (this.source instanceof BaseCommand) {
+            return this.source.containsType(type);
         }
-        return `${reason} -> ${this._commandType}(${this.reason})`;
+        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 */
+    _commandType: 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;
+}