hoffmation-base 3.0.3 → 3.1.1

package/lib/command/actuatorToggleCommand.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource, CommandType } from '../enums';
+export declare class ActuatorToggleCommand extends BaseCommand {
+    /** @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);
+}

package/lib/command/actuatorToggleCommand.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActuatorToggleCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const enums_1 = require("../enums");
+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.type = enums_1.CommandType.ActuatorToggleCommand;
+    }
+}
+exports.ActuatorToggleCommand = ActuatorToggleCommand;

package/lib/command/actuatorWriteStateToDeviceCommand.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource, CommandType } from '../enums';
+export declare class ActuatorWriteStateToDeviceCommand extends BaseCommand {
+    readonly stateValue: boolean;
+    /** @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/command/actuatorWriteStateToDeviceCommand.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActuatorWriteStateToDeviceCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const enums_1 = require("../enums");
+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;
+        /** @inheritDoc */
+        this.type = enums_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}`;
+    }
+}
+exports.ActuatorWriteStateToDeviceCommand = ActuatorWriteStateToDeviceCommand;

package/lib/command/baseCommand.d.ts

@@ -0,0 +1,32 @@
+import { CommandSource, CommandType } from '../enums';
+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 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/command/baseCommand.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+const enums_1 = require("../enums");
+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 = enums_1.CommandSource.Unknown, reason = '') {
+        this.source = source;
+        this.reason = reason;
+        this.timestamp = new Date();
+    }
+    get isAutomaticAction() {
+        if (this.overrideCommandSource !== undefined) {
+            return this.overrideCommandSource === enums_1.CommandSource.Automatic;
+        }
+        if (this.source instanceof BaseCommand) {
+            return this.source.isAutomaticAction;
+        }
+        return this.source === enums_1.CommandSource.Automatic;
+    }
+    get isForceAction() {
+        if (this.overrideCommandSource !== undefined) {
+            return (this.overrideCommandSource === enums_1.CommandSource.Manual ||
+                this.overrideCommandSource === enums_1.CommandSource.API ||
+                this.overrideCommandSource === enums_1.CommandSource.Force);
+        }
+        if (this.source instanceof BaseCommand) {
+            return this.source.isForceAction;
+        }
+        return (this.source === enums_1.CommandSource.Manual || this.source === enums_1.CommandSource.API || this.source === enums_1.CommandSource.Force);
+    }
+    get isManual() {
+        if (this.overrideCommandSource !== undefined) {
+            return this.overrideCommandSource === enums_1.CommandSource.Manual || this.overrideCommandSource === enums_1.CommandSource.API;
+        }
+        if (this.source instanceof BaseCommand) {
+            return this.source.isManual;
+        }
+        return this.source === enums_1.CommandSource.Manual || this.source === enums_1.CommandSource.API;
+    }
+    get isInitial() {
+        if (this.overrideCommandSource !== undefined) {
+            return this.overrideCommandSource === enums_1.CommandSource.Initial;
+        }
+        if (this.source instanceof BaseCommand) {
+            return this.source.isInitial;
+        }
+        return this.source === enums_1.CommandSource.Initial;
+    }
+    get reasonTrace() {
+        const ownPart = this.reason !== '' ? `${this.type}("${this.reason}")` : `${this.type}`;
+        if (typeof this.source === 'object') {
+            return `${this.source.reasonTrace} -> ${ownPart}`;
+        }
+        return `CommandType("${enums_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/command/blockAutomaticCommand.d.ts

@@ -0,0 +1,40 @@
+import { BaseCommand } from './baseCommand';
+import { CollisionSolving, CommandSource, CommandType } from '../enums';
+export declare class BlockAutomaticCommand extends BaseCommand {
+    /**
+     * Whether at Block-Lift the desired automatic state should be restored.
+     */
+    static defaultRevertToAutomaticAtBlockLift?: boolean;
+    /**
+     * The default duration in milliseconds for a block to be on any force action.
+     */
+    static defaultBlockAutomaticDurationMS?: number;
+    /**
+     * The default collision solving strategy to use.
+     */
+    static defaultDefaultCollisionSolving?: CollisionSolving;
+    /** @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;
+}

package/lib/command/blockAutomaticCommand.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAutomaticCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const enums_1 = require("../enums");
+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;
+        super(source, reason);
+        /** @inheritDoc */
+        this.type = enums_1.CommandType.BlockAutomaticCommand;
+        this.durationMS = (_a = durationMS !== null && durationMS !== void 0 ? durationMS : BlockAutomaticCommand.defaultBlockAutomaticDurationMS) !== null && _a !== void 0 ? _a : 30 * 60 * 1000;
+        this.revertToAutomaticAtBlockLift =
+            (_b = revertToAutomaticAtBlockLift !== null && revertToAutomaticAtBlockLift !== void 0 ? revertToAutomaticAtBlockLift : BlockAutomaticCommand.defaultRevertToAutomaticAtBlockLift) !== null && _b !== void 0 ? _b : true;
+        this.onCollideAction =
+            (_c = onCollideAction !== null && onCollideAction !== void 0 ? onCollideAction : BlockAutomaticCommand.defaultDefaultCollisionSolving) !== null && _c !== void 0 ? _c : enums_1.CollisionSolving.overrideIfGreater;
+    }
+    get logMessage() {
+        return `BlockAutomatic for ${this.durationMS}ms with onCollideAction ${this.onCollideAction} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.BlockAutomaticCommand = BlockAutomaticCommand;

package/lib/command/blockAutomaticLiftBlockCommand.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource, CommandType } from '../enums';
+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/command/blockAutomaticLiftBlockCommand.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAutomaticLiftBlockCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const enums_1 = require("../enums");
+const blockAutomaticCommand_1 = require("./blockAutomaticCommand");
+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;
+        super(source, reason);
+        /** @inheritDoc */
+        this.type = enums_1.CommandType.BlockAutomaticLiftBlockCommand;
+        this.revertToAutomatic = (_a = revertToAutomatic !== null && revertToAutomatic !== void 0 ? revertToAutomatic : blockAutomaticCommand_1.BlockAutomaticCommand.defaultRevertToAutomaticAtBlockLift) !== null && _a !== void 0 ? _a : true;
+    }
+}
+exports.BlockAutomaticLiftBlockCommand = BlockAutomaticLiftBlockCommand;

package/lib/command/blockAutomaticUntilCommand.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from './baseCommand';
+import { CollisionSolving, CommandSource, CommandType } from '../enums';
+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/command/blockAutomaticUntilCommand.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockAutomaticUntilCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const enums_1 = require("../enums");
+const blockAutomaticCommand_1 = require("./blockAutomaticCommand");
+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;
+        super(source, reason);
+        this.targetDate = targetDate;
+        /** @inheritDoc */
+        this.type = enums_1.CommandType.BlockAutomaticUntilCommand;
+        this.onCollideAction =
+            (_a = onCollideAction !== null && onCollideAction !== void 0 ? onCollideAction : blockAutomaticCommand_1.BlockAutomaticCommand.defaultDefaultCollisionSolving) !== null && _a !== void 0 ? _a : enums_1.CollisionSolving.overrideIfGreater;
+        this.revertToAutomaticAtBlockLift =
+            (_b = revertToAutomaticAtBlockLift !== null && revertToAutomaticAtBlockLift !== void 0 ? revertToAutomaticAtBlockLift : blockAutomaticCommand_1.BlockAutomaticCommand.defaultRevertToAutomaticAtBlockLift) !== null && _b !== void 0 ? _b : true;
+    }
+    get logMessage() {
+        return `Block automatic until ${this.targetDate.toLocaleString('de-DE')}, reason: ${this.reasonTrace}`;
+    }
+}
+exports.BlockAutomaticUntilCommand = BlockAutomaticUntilCommand;

package/lib/command/dimmerSetLightCommand.d.ts

@@ -0,0 +1,23 @@
+import { LampSetLightCommand } from './lampSetLightCommand';
+import { CommandSource, CommandType } from '../enums';
+import { BaseCommand } from './baseCommand';
+import { BlockAutomaticCommand } from './blockAutomaticCommand';
+export declare class DimmerSetLightCommand extends LampSetLightCommand {
+    brightness: number;
+    transitionTime: number;
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Command to change the light of a dimmer
+     * @param source - The source of the command
+     * @param on - The desired value
+     * @param reason - You can provide a reason for clarity
+     * @param disableAutomatic - If provided, the device will remain in the desired state for the given disable action.
+     * If undefined the default value will be used in case it's a non automatic action: {@link SettingsService.settings.blockAutomaticHandlerDefaults}
+     * @param brightness - The desired brightness
+     * @param transitionTime - The transition time during turnOn/turnOff
+     */
+    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, disableAutomatic?: BlockAutomaticCommand | null, brightness?: number, transitionTime?: number);
+    /** @inheritDoc */
+    get logMessage(): string;
+}

package/lib/command/dimmerSetLightCommand.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DimmerSetLightCommand = void 0;
+const lampSetLightCommand_1 = require("./lampSetLightCommand");
+const enums_1 = require("../enums");
+class DimmerSetLightCommand extends lampSetLightCommand_1.LampSetLightCommand {
+    /**
+     * Command to change the light of a dimmer
+     * @param source - The source of the command
+     * @param on - The desired value
+     * @param reason - You can provide a reason for clarity
+     * @param disableAutomatic - If provided, the device will remain in the desired state for the given disable action.
+     * If undefined the default value will be used in case it's a non automatic action: {@link SettingsService.settings.blockAutomaticHandlerDefaults}
+     * @param brightness - The desired brightness
+     * @param transitionTime - The transition time during turnOn/turnOff
+     */
+    constructor(source, on, reason = '', disableAutomatic, brightness = -1, transitionTime = -1) {
+        super(source, on, reason, disableAutomatic);
+        this.brightness = brightness;
+        this.transitionTime = transitionTime;
+        /** @inheritDoc */
+        this.type = enums_1.CommandType.DimmerSetLightCommand;
+    }
+    /** @inheritDoc */
+    get logMessage() {
+        var _a;
+        return `Dimmer setLight to ${this.on} with Brightness ${this.brightness} with disable ${(_a = this.disableAutomaticCommand) === null || _a === void 0 ? void 0 : _a.logMessage} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.DimmerSetLightCommand = DimmerSetLightCommand;

package/lib/command/floorSetAllShuttersCommand.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource, CommandType } from '../enums';
+export declare class FloorSetAllShuttersCommand extends BaseCommand {
+    readonly position: number;
+    readonly specificFloor: number | undefined;
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Creates an instance of FloorSetAllShuttersCommand.
+     * @param source - The source of the command
+     * @param position - (0 closed, 100 open)
+     * @param specificFloor - undefined = all floors
+     * @param reason - You can provide a reason for clarity
+     */
+    constructor(source: CommandSource | BaseCommand, position: number, specificFloor?: number | undefined, reason?: string);
+}

package/lib/command/floorSetAllShuttersCommand.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloorSetAllShuttersCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const enums_1 = require("../enums");
+class FloorSetAllShuttersCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Creates an instance of FloorSetAllShuttersCommand.
+     * @param source - The source of the command
+     * @param position - (0 closed, 100 open)
+     * @param specificFloor - undefined = all floors
+     * @param reason - You can provide a reason for clarity
+     */
+    constructor(source, position, specificFloor = undefined, reason = '') {
+        super(source, reason);
+        this.position = position;
+        this.specificFloor = specificFloor;
+        /** @inheritDoc */
+        this.type = enums_1.CommandType.FloorSetAllShuttersCommand;
+    }
+}
+exports.FloorSetAllShuttersCommand = FloorSetAllShuttersCommand;

package/lib/command/index.d.ts

@@ -0,0 +1,25 @@
+export { BlockAutomaticCommand } from './blockAutomaticCommand';
+export { BlockAutomaticUntilCommand } from './blockAutomaticUntilCommand';
+export { BlockAutomaticLiftBlockCommand } from './blockAutomaticLiftBlockCommand';
+export { RestoreTargetAutomaticValueCommand } from './restoreTargetAutomaticValueCommand';
+export { ActuatorSetStateCommand } from './actuatorSetStateCommand';
+export { ActuatorToggleCommand } from './actuatorToggleCommand';
+export { ActuatorWriteStateToDeviceCommand } from './actuatorWriteStateToDeviceCommand';
+export { BaseCommand } from './baseCommand';
+export { DimmerSetLightCommand } from './dimmerSetLightCommand';
+export { FloorSetAllShuttersCommand } from './floorSetAllShuttersCommand';
+export { LampSetLightCommand } from './lampSetLightCommand';
+export { LampSetTimeBasedCommand } from './lampSetTimeBasedCommand';
+export { LampToggleLightCommand } from './lampToggleLightCommand';
+export { LedSetLightCommand } from './ledSetLightCommand';
+export { LightGroupSwitchTimeConditionalCommand } from './lightGroupSwitchTimeConditionalCommand';
+export { RoomRestoreLightCommand } from './roomRestoreLightCommand';
+export { RoomRestoreShutterPositionCommand } from './roomRestoreShutterPositionCommand';
+export { RoomSetLightTimeBasedCommand } from './roomSetLightTimeBasedCommand';
+export { ShutterSetLevelCommand } from './ShutterSetLevelCommand';
+export { ShutterSunriseUpCommand } from './shutterSunriseUpCommand';
+export { ShutterSunsetDownCommand } from './shutterSunsetDownCommand';
+export { WindowRestoreDesiredPositionCommand } from './WindowRestoreDesiredPositionCommand';
+export { WindowSetDesiredPositionCommand } from './WindowSetDesiredPositionCommand';
+export { WindowSetRolloByWeatherStatusCommand } from './WindowSetRolloByWeatherStatusCommand';
+export { WledSetLightCommand } from './wledSetLightCommand';

package/lib/command/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WledSetLightCommand = exports.WindowSetRolloByWeatherStatusCommand = exports.WindowSetDesiredPositionCommand = exports.WindowRestoreDesiredPositionCommand = exports.ShutterSunsetDownCommand = exports.ShutterSunriseUpCommand = exports.ShutterSetLevelCommand = exports.RoomSetLightTimeBasedCommand = exports.RoomRestoreShutterPositionCommand = exports.RoomRestoreLightCommand = exports.LightGroupSwitchTimeConditionalCommand = exports.LedSetLightCommand = exports.LampToggleLightCommand = exports.LampSetTimeBasedCommand = exports.LampSetLightCommand = exports.FloorSetAllShuttersCommand = exports.DimmerSetLightCommand = exports.BaseCommand = exports.ActuatorWriteStateToDeviceCommand = exports.ActuatorToggleCommand = exports.ActuatorSetStateCommand = exports.RestoreTargetAutomaticValueCommand = exports.BlockAutomaticLiftBlockCommand = exports.BlockAutomaticUntilCommand = exports.BlockAutomaticCommand = void 0;
+var blockAutomaticCommand_1 = require("./blockAutomaticCommand");
+Object.defineProperty(exports, "BlockAutomaticCommand", { enumerable: true, get: function () { return blockAutomaticCommand_1.BlockAutomaticCommand; } });
+var blockAutomaticUntilCommand_1 = require("./blockAutomaticUntilCommand");
+Object.defineProperty(exports, "BlockAutomaticUntilCommand", { enumerable: true, get: function () { return blockAutomaticUntilCommand_1.BlockAutomaticUntilCommand; } });
+var blockAutomaticLiftBlockCommand_1 = require("./blockAutomaticLiftBlockCommand");
+Object.defineProperty(exports, "BlockAutomaticLiftBlockCommand", { enumerable: true, get: function () { return blockAutomaticLiftBlockCommand_1.BlockAutomaticLiftBlockCommand; } });
+var restoreTargetAutomaticValueCommand_1 = require("./restoreTargetAutomaticValueCommand");
+Object.defineProperty(exports, "RestoreTargetAutomaticValueCommand", { enumerable: true, get: function () { return restoreTargetAutomaticValueCommand_1.RestoreTargetAutomaticValueCommand; } });
+var actuatorSetStateCommand_1 = require("./actuatorSetStateCommand");
+Object.defineProperty(exports, "ActuatorSetStateCommand", { enumerable: true, get: function () { return actuatorSetStateCommand_1.ActuatorSetStateCommand; } });
+var actuatorToggleCommand_1 = require("./actuatorToggleCommand");
+Object.defineProperty(exports, "ActuatorToggleCommand", { enumerable: true, get: function () { return actuatorToggleCommand_1.ActuatorToggleCommand; } });
+var actuatorWriteStateToDeviceCommand_1 = require("./actuatorWriteStateToDeviceCommand");
+Object.defineProperty(exports, "ActuatorWriteStateToDeviceCommand", { enumerable: true, get: function () { return actuatorWriteStateToDeviceCommand_1.ActuatorWriteStateToDeviceCommand; } });
+var baseCommand_1 = require("./baseCommand");
+Object.defineProperty(exports, "BaseCommand", { enumerable: true, get: function () { return baseCommand_1.BaseCommand; } });
+var dimmerSetLightCommand_1 = require("./dimmerSetLightCommand");
+Object.defineProperty(exports, "DimmerSetLightCommand", { enumerable: true, get: function () { return dimmerSetLightCommand_1.DimmerSetLightCommand; } });
+var floorSetAllShuttersCommand_1 = require("./floorSetAllShuttersCommand");
+Object.defineProperty(exports, "FloorSetAllShuttersCommand", { enumerable: true, get: function () { return floorSetAllShuttersCommand_1.FloorSetAllShuttersCommand; } });
+var lampSetLightCommand_1 = require("./lampSetLightCommand");
+Object.defineProperty(exports, "LampSetLightCommand", { enumerable: true, get: function () { return lampSetLightCommand_1.LampSetLightCommand; } });
+var lampSetTimeBasedCommand_1 = require("./lampSetTimeBasedCommand");
+Object.defineProperty(exports, "LampSetTimeBasedCommand", { enumerable: true, get: function () { return lampSetTimeBasedCommand_1.LampSetTimeBasedCommand; } });
+var lampToggleLightCommand_1 = require("./lampToggleLightCommand");
+Object.defineProperty(exports, "LampToggleLightCommand", { enumerable: true, get: function () { return lampToggleLightCommand_1.LampToggleLightCommand; } });
+var ledSetLightCommand_1 = require("./ledSetLightCommand");
+Object.defineProperty(exports, "LedSetLightCommand", { enumerable: true, get: function () { return ledSetLightCommand_1.LedSetLightCommand; } });
+var lightGroupSwitchTimeConditionalCommand_1 = require("./lightGroupSwitchTimeConditionalCommand");
+Object.defineProperty(exports, "LightGroupSwitchTimeConditionalCommand", { enumerable: true, get: function () { return lightGroupSwitchTimeConditionalCommand_1.LightGroupSwitchTimeConditionalCommand; } });
+var roomRestoreLightCommand_1 = require("./roomRestoreLightCommand");
+Object.defineProperty(exports, "RoomRestoreLightCommand", { enumerable: true, get: function () { return roomRestoreLightCommand_1.RoomRestoreLightCommand; } });
+var roomRestoreShutterPositionCommand_1 = require("./roomRestoreShutterPositionCommand");
+Object.defineProperty(exports, "RoomRestoreShutterPositionCommand", { enumerable: true, get: function () { return roomRestoreShutterPositionCommand_1.RoomRestoreShutterPositionCommand; } });
+var roomSetLightTimeBasedCommand_1 = require("./roomSetLightTimeBasedCommand");
+Object.defineProperty(exports, "RoomSetLightTimeBasedCommand", { enumerable: true, get: function () { return roomSetLightTimeBasedCommand_1.RoomSetLightTimeBasedCommand; } });
+var ShutterSetLevelCommand_1 = require("./ShutterSetLevelCommand");
+Object.defineProperty(exports, "ShutterSetLevelCommand", { enumerable: true, get: function () { return ShutterSetLevelCommand_1.ShutterSetLevelCommand; } });
+var shutterSunriseUpCommand_1 = require("./shutterSunriseUpCommand");
+Object.defineProperty(exports, "ShutterSunriseUpCommand", { enumerable: true, get: function () { return shutterSunriseUpCommand_1.ShutterSunriseUpCommand; } });
+var shutterSunsetDownCommand_1 = require("./shutterSunsetDownCommand");
+Object.defineProperty(exports, "ShutterSunsetDownCommand", { enumerable: true, get: function () { return shutterSunsetDownCommand_1.ShutterSunsetDownCommand; } });
+var WindowRestoreDesiredPositionCommand_1 = require("./WindowRestoreDesiredPositionCommand");
+Object.defineProperty(exports, "WindowRestoreDesiredPositionCommand", { enumerable: true, get: function () { return WindowRestoreDesiredPositionCommand_1.WindowRestoreDesiredPositionCommand; } });
+var WindowSetDesiredPositionCommand_1 = require("./WindowSetDesiredPositionCommand");
+Object.defineProperty(exports, "WindowSetDesiredPositionCommand", { enumerable: true, get: function () { return WindowSetDesiredPositionCommand_1.WindowSetDesiredPositionCommand; } });
+var WindowSetRolloByWeatherStatusCommand_1 = require("./WindowSetRolloByWeatherStatusCommand");
+Object.defineProperty(exports, "WindowSetRolloByWeatherStatusCommand", { enumerable: true, get: function () { return WindowSetRolloByWeatherStatusCommand_1.WindowSetRolloByWeatherStatusCommand; } });
+var wledSetLightCommand_1 = require("./wledSetLightCommand");
+Object.defineProperty(exports, "WledSetLightCommand", { enumerable: true, get: function () { return wledSetLightCommand_1.WledSetLightCommand; } });

package/lib/command/lampSetLightCommand.d.ts

@@ -0,0 +1,19 @@
+import { ActuatorSetStateCommand } from './actuatorSetStateCommand';
+import { CommandSource, CommandType } from '../enums';
+import { BaseCommand } from './baseCommand';
+import { BlockAutomaticCommand } from './blockAutomaticCommand';
+export declare class LampSetLightCommand extends ActuatorSetStateCommand {
+    /** @inheritDoc */
+    type: CommandType;
+    /**
+     * Command to set the light of a lamp
+     * @param source - The source of the command
+     * @param on - The new state of the light
+     * @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 undefined the default value will be used in case it's a non automatic action: {@link SettingsService.settings.blockAutomaticHandlerDefaults}
+     */
+    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, disableAutomatic?: BlockAutomaticCommand | null);
+    /** @inheritDoc */
+    get logMessage(): string;
+}

package/lib/command/lampSetLightCommand.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LampSetLightCommand = void 0;
+const actuatorSetStateCommand_1 = require("./actuatorSetStateCommand");
+const enums_1 = require("../enums");
+class LampSetLightCommand extends actuatorSetStateCommand_1.ActuatorSetStateCommand {
+    /**
+     * Command to set the light of a lamp
+     * @param source - The source of the command
+     * @param on - The new state of the light
+     * @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 undefined the default value will be used in case it's a non automatic action: {@link SettingsService.settings.blockAutomaticHandlerDefaults}
+     */
+    constructor(source, on, reason = '', disableAutomatic) {
+        super(source, on, reason, disableAutomatic);
+        /** @inheritDoc */
+        this.type = enums_1.CommandType.LampSetLightCommand;
+    }
+    /** @inheritDoc */
+    get logMessage() {
+        var _a;
+        return `Lamp setLight to ${this.on} with block ${(_a = this.disableAutomaticCommand) === null || _a === void 0 ? void 0 : _a.logMessage} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.LampSetLightCommand = LampSetLightCommand;

package/lib/command/lampSetTimeBasedCommand.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource, CommandType, TimeOfDay } from '../enums';
+import { BlockAutomaticCommand } from './blockAutomaticCommand';
+export declare class LampSetTimeBasedCommand extends BaseCommand {
+    time: TimeOfDay;
+    /** @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
+     */
+    readonly disableAutomaticCommand: BlockAutomaticCommand | null | undefined;
+    /**
+     * Set's the lamp based on lamp settings for the current time
+     * @param source - The source of the command
+     * @param time - The time to use for calculation of desired state
+     * @param reason - You can provide a reason for clarity
+     * @param disableAutomatic - If provided, the device will remain in the desired state for the given disable action.
+     * If undefined the default value will be used in case it's a non automatic action: {@link SettingsService.settings.blockAutomaticHandlerDefaults}
+     */
+    constructor(source: CommandSource | BaseCommand, time: TimeOfDay, reason?: string, disableAutomatic?: BlockAutomaticCommand | null);
+}

package/lib/command/lampSetTimeBasedCommand.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LampSetTimeBasedCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const enums_1 = require("../enums");
+class LampSetTimeBasedCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Set's the lamp based on lamp settings for the current time
+     * @param source - The source of the command
+     * @param time - The time to use for calculation of desired state
+     * @param reason - You can provide a reason for clarity
+     * @param disableAutomatic - If provided, the device will remain in the desired state for the given disable action.
+     * If undefined the default value will be used in case it's a non automatic action: {@link SettingsService.settings.blockAutomaticHandlerDefaults}
+     */
+    constructor(source, time, reason = '', disableAutomatic) {
+        super(source, reason);
+        this.time = time;
+        /** @inheritDoc */
+        this.type = enums_1.CommandType.LampSetTimeBasedCommand;
+        this.disableAutomaticCommand = disableAutomatic;
+    }
+}
+exports.LampSetTimeBasedCommand = LampSetTimeBasedCommand;