hoffmation-base 2.22.18 → 3.0.0-alpha.0

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

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

package/lib/models/command/ShutterSetLevelCommand.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShutterSetLevelCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class ShutterSetLevelCommand extends baseCommand_1.BaseCommand {
+    constructor(source, level, reason = '', skipOpenWarning = false) {
+        super(source, reason);
+        this.level = level;
+        this.skipOpenWarning = skipOpenWarning;
+        this._commandType = commandType_1.CommandType.ShutterSetLevelCommand;
+    }
+    get logMessage() {
+        return `Shutter setLevel to ${this.level} from ${this.source} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.ShutterSetLevelCommand = ShutterSetLevelCommand;

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

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

package/lib/models/command/WindowRestoreDesiredPositionCommand.js

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

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

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

package/lib/models/command/WindowSetDesiredPositionCommand.js

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

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

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

package/lib/models/command/WindowSetRolloByWeatherStatusCommand.js

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

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

@@ -0,0 +1,13 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource } from './commandSource';
+import { CommandType } from './commandType';
+import { ActuatorToggleCommand } from './actuatorToggleCommand';
+import { iActuator } from '../../server';
+export declare class ActuatorSetStateCommand extends BaseCommand {
+    readonly on: boolean;
+    timeout: number;
+    _commandType: CommandType;
+    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, timeout?: number);
+    get logMessage(): string;
+    static byActuatorAndToggleCommand(device: iActuator, c: ActuatorToggleCommand): ActuatorSetStateCommand;
+}

package/lib/models/command/actuatorSetStateCommand.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+        super(source, reason);
+        this.on = on;
+        this.timeout = timeout;
+        this._commandType = commandType_1.CommandType.ShutterSetLevelCommand;
+    }
+    get logMessage() {
+        return `Actuator setState to ${this.on} from ${this.source} 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);
+    }
+}
+exports.ActuatorSetStateCommand = ActuatorSetStateCommand;

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

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

package/lib/models/command/actuatorToggleCommand.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActuatorToggleCommand = void 0;
+const commandType_1 = require("./commandType");
+const baseCommand_1 = require("./baseCommand");
+class ActuatorToggleCommand extends baseCommand_1.BaseCommand {
+    constructor(source, reason = '') {
+        super(source, reason);
+        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

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

package/lib/models/command/actuatorWriteStateToDeviceCommand.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActuatorWriteStateToDeviceCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class ActuatorWriteStateToDeviceCommand extends baseCommand_1.BaseCommand {
+    constructor(stateValue, source, reason = '') {
+        super(source, reason);
+        this.stateValue = stateValue;
+        this._commandType = commandType_1.CommandType.ActuatorWriteStateToDeviceCommand;
+    }
+    get logMessage() {
+        return `Actuator writeStateToDevice(${this.stateValue}) due to ${this.source} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.ActuatorWriteStateToDeviceCommand = ActuatorWriteStateToDeviceCommand;

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

@@ -0,0 +1,12 @@
+import { CommandSource } from './commandSource';
+import { CommandType } from './commandType';
+export declare abstract class BaseCommand {
+    readonly source: CommandSource | BaseCommand;
+    readonly reason: string;
+    readonly timestamp: Date;
+    abstract _commandType: CommandType;
+    constructor(source?: CommandSource | BaseCommand, reason?: string);
+    get isForceAction(): boolean;
+    get isInitial(): boolean;
+    get reasonTrace(): string;
+}

package/lib/models/command/baseCommand.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+const commandSource_1 = require("./commandSource");
+class BaseCommand {
+    constructor(source = commandSource_1.CommandSource.Unknown, reason = '') {
+        this.source = source;
+        this.reason = reason;
+        this.timestamp = new Date();
+    }
+    get isForceAction() {
+        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 isInitial() {
+        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;
+        }
+        if (this.reason === '') {
+            return `${reason} -> ${this._commandType}`;
+        }
+        return `${reason} -> ${this._commandType}(${this.reason})`;
+    }
+}
+exports.BaseCommand = BaseCommand;

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

@@ -0,0 +1,8 @@
+export declare enum CommandSource {
+    Unknown = 0,
+    Initial = 1,
+    Automatic = 2,
+    Manual = 3,
+    API = 4,
+    Force = 5
+}

package/lib/models/command/commandSource.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandSource = void 0;
+var CommandSource;
+(function (CommandSource) {
+    CommandSource[CommandSource["Unknown"] = 0] = "Unknown";
+    CommandSource[CommandSource["Initial"] = 1] = "Initial";
+    CommandSource[CommandSource["Automatic"] = 2] = "Automatic";
+    CommandSource[CommandSource["Manual"] = 3] = "Manual";
+    CommandSource[CommandSource["API"] = 4] = "API";
+    CommandSource[CommandSource["Force"] = 5] = "Force";
+})(CommandSource || (exports.CommandSource = CommandSource = {}));

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

@@ -0,0 +1,23 @@
+export declare enum CommandType {
+    ActuatorToggleCommand = "ActuatorToggleCommand",
+    ActuatorSetStateCommand = "ActuatorSetStateCommand",
+    ActuatorRestoreTargetAutomaticValueCommand = "ActuatorRestoreTargetAutomaticValueCommand",
+    ActuatorWriteStateToDeviceCommand = "ActuatorWriteStateToDeviceCommand",
+    DimmerSetLightCommand = "DimmerSetLightCommand",
+    FloorSetAllShuttersCommand = "FloorSetAllShuttersCommand",
+    LampSetLightCommand = "LampSetLightCommand",
+    LampSetTimeBasedCommand = "LampSetTimeBasedCommand",
+    LampToggleLightCommand = "LampToggleLightCommand",
+    LedSetLightCommand = "LedSetLightCommand",
+    LightGroupSwitchTimeConditional = "LightGroupSwitchTimeConditional",
+    RoomRestoreShutterPositionCommand = "RoomRestoreShutterPositionCommand",
+    RoomRestoreLightCommand = "RoomRestoreLightCommand",
+    RoomSetLightTimeBasedCommand = "RoomSetLightTimeBasedCommand",
+    ShutterSetLevelCommand = "ShutterSetLevelCommand",
+    ShutterSunriseUpCommand = "ShutterSunriseUpCommand",
+    SunsetDownCommand = "SunsetDownCommand",
+    WindowRestoreDesiredPositionCommand = "WindowRestoreDesiredPositionCommand",
+    WindowSetDesiredPositionCommand = "WindowSetDesiredPositionCommand",
+    WindowSetRolloByWeatherStatusCommand = "WindowSetRolloByWeatherStatusCommand",
+    WledSetLightCommand = "WledSetLightCommand"
+}

package/lib/models/command/commandType.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandType = void 0;
+var CommandType;
+(function (CommandType) {
+    CommandType["ActuatorToggleCommand"] = "ActuatorToggleCommand";
+    CommandType["ActuatorSetStateCommand"] = "ActuatorSetStateCommand";
+    CommandType["ActuatorRestoreTargetAutomaticValueCommand"] = "ActuatorRestoreTargetAutomaticValueCommand";
+    CommandType["ActuatorWriteStateToDeviceCommand"] = "ActuatorWriteStateToDeviceCommand";
+    CommandType["DimmerSetLightCommand"] = "DimmerSetLightCommand";
+    CommandType["FloorSetAllShuttersCommand"] = "FloorSetAllShuttersCommand";
+    CommandType["LampSetLightCommand"] = "LampSetLightCommand";
+    CommandType["LampSetTimeBasedCommand"] = "LampSetTimeBasedCommand";
+    CommandType["LampToggleLightCommand"] = "LampToggleLightCommand";
+    CommandType["LedSetLightCommand"] = "LedSetLightCommand";
+    CommandType["LightGroupSwitchTimeConditional"] = "LightGroupSwitchTimeConditional";
+    CommandType["RoomRestoreShutterPositionCommand"] = "RoomRestoreShutterPositionCommand";
+    CommandType["RoomRestoreLightCommand"] = "RoomRestoreLightCommand";
+    CommandType["RoomSetLightTimeBasedCommand"] = "RoomSetLightTimeBasedCommand";
+    CommandType["ShutterSetLevelCommand"] = "ShutterSetLevelCommand";
+    CommandType["ShutterSunriseUpCommand"] = "ShutterSunriseUpCommand";
+    CommandType["SunsetDownCommand"] = "SunsetDownCommand";
+    CommandType["WindowRestoreDesiredPositionCommand"] = "WindowRestoreDesiredPositionCommand";
+    CommandType["WindowSetDesiredPositionCommand"] = "WindowSetDesiredPositionCommand";
+    CommandType["WindowSetRolloByWeatherStatusCommand"] = "WindowSetRolloByWeatherStatusCommand";
+    CommandType["WledSetLightCommand"] = "WledSetLightCommand";
+})(CommandType || (exports.CommandType = CommandType = {}));

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

@@ -0,0 +1,22 @@
+import { LampSetLightCommand } from './lampSetLightCommand';
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { BaseCommand } from './baseCommand';
+import { LampSetTimeBasedCommand } from './lampSetTimeBasedCommand';
+import { DimmerSettings } from '../deviceSettings';
+export declare class DimmerSetLightCommand extends LampSetLightCommand {
+    brightness: number;
+    transitionTime: number;
+    _commandType: CommandType;
+    /**
+     * @param {CommandSource | BaseCommand} source
+     * @param {boolean} on The desired value
+     * @param {string} reason
+     * @param {number} timeout  A chosen Timeout after which the light should be reset
+     * @param {number} brightness The desired brightness
+     * @param {number} transitionTime The transition time during turnOn/turnOff
+     */
+    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, timeout?: number, brightness?: number, transitionTime?: number);
+    get logMessage(): string;
+    static byTimeBased(s: DimmerSettings, c: LampSetTimeBasedCommand): DimmerSetLightCommand;
+}

package/lib/models/command/dimmerSetLightCommand.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DimmerSetLightCommand = void 0;
+const lampSetLightCommand_1 = require("./lampSetLightCommand");
+const commandType_1 = require("./commandType");
+const timeCallback_1 = require("../timeCallback");
+class DimmerSetLightCommand extends lampSetLightCommand_1.LampSetLightCommand {
+    /**
+     * @param {CommandSource | BaseCommand} source
+     * @param {boolean} on The desired value
+     * @param {string} reason
+     * @param {number} timeout  A chosen Timeout after which the light should be reset
+     * @param {number} brightness The desired brightness
+     * @param {number} transitionTime The transition time during turnOn/turnOff
+     */
+    constructor(source, on, reason = '', timeout = -1, brightness = -1, transitionTime = -1) {
+        super(source, on, reason, timeout);
+        this.brightness = brightness;
+        this.transitionTime = transitionTime;
+        this._commandType = commandType_1.CommandType.DimmerSetLightCommand;
+    }
+    get logMessage() {
+        return `Dimmer setLight to ${this.on} from ${this.source} for reason: ${this.reasonTrace}`;
+    }
+    static byTimeBased(s, c) {
+        switch (c.time) {
+            case timeCallback_1.TimeOfDay.Daylight:
+                return new DimmerSetLightCommand(c, true, 'By TimeBased Daylight', c.timeout, s.dayBrightness);
+            case timeCallback_1.TimeOfDay.BeforeSunrise:
+                return new DimmerSetLightCommand(c, s.dawnOn, '', c.timeout, s.dawnBrightness, undefined);
+            case timeCallback_1.TimeOfDay.AfterSunset:
+                return new DimmerSetLightCommand(c, s.duskOn, '', c.timeout, s.duskBrightness, undefined);
+            case timeCallback_1.TimeOfDay.Night:
+                return new DimmerSetLightCommand(c, s.nightOn, '', c.timeout, s.nightBrightness, undefined);
+            default:
+                throw new Error(`TimeOfDay ${c.time} not supported`);
+        }
+    }
+}
+exports.DimmerSetLightCommand = DimmerSetLightCommand;

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

@@ -0,0 +1,16 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource } from './commandSource';
+import { CommandType } from './commandType';
+export declare class FloorSetAllShuttersCommand extends BaseCommand {
+    readonly position: number;
+    readonly specificFloor: number | undefined;
+    _commandType: CommandType;
+    /**
+     * Creates an instance of FloorSetAllShuttersCommand.
+     * @param {CommandSource | BaseCommand} source
+     * @param {number} position (0 closed, 100 open)
+     * @param {number | undefined} specificFloor  undefined = all floors
+     * @param {string} reason
+     */
+    constructor(source: CommandSource | BaseCommand, position: number, specificFloor?: number | undefined, reason?: string);
+}

package/lib/models/command/floorSetAllShuttersCommand.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloorSetAllShuttersCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+class FloorSetAllShuttersCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Creates an instance of FloorSetAllShuttersCommand.
+     * @param {CommandSource | BaseCommand} source
+     * @param {number} position (0 closed, 100 open)
+     * @param {number | undefined} specificFloor  undefined = all floors
+     * @param {string} reason
+     */
+    constructor(source, position, specificFloor = undefined, reason = '') {
+        super(source, reason);
+        this.position = position;
+        this.specificFloor = specificFloor;
+        this._commandType = commandType_1.CommandType.FloorSetAllShuttersCommand;
+    }
+}
+exports.FloorSetAllShuttersCommand = FloorSetAllShuttersCommand;

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

@@ -0,0 +1,24 @@
+export { RestoreTargetAutomaticValueCommand } from './restoreTargetAutomaticValueCommand';
+export { ActuatorSetStateCommand } from './actuatorSetStateCommand';
+export { ActuatorToggleCommand } from './actuatorToggleCommand';
+export { ActuatorWriteStateToDeviceCommand } from './actuatorWriteStateToDeviceCommand';
+export { BaseCommand } from './baseCommand';
+export { CommandSource } from './commandSource';
+export { CommandType } from './commandType';
+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/models/command/index.js

@@ -0,0 +1,51 @@
+"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.CommandType = exports.CommandSource = exports.BaseCommand = exports.ActuatorWriteStateToDeviceCommand = exports.ActuatorToggleCommand = exports.ActuatorSetStateCommand = exports.RestoreTargetAutomaticValueCommand = void 0;
+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 commandSource_1 = require("./commandSource");
+Object.defineProperty(exports, "CommandSource", { enumerable: true, get: function () { return commandSource_1.CommandSource; } });
+var commandType_1 = require("./commandType");
+Object.defineProperty(exports, "CommandType", { enumerable: true, get: function () { return commandType_1.CommandType; } });
+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/models/command/lampSetLightCommand.d.ts

@@ -0,0 +1,9 @@
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { BaseCommand } from './baseCommand';
+import { ActuatorSetStateCommand } from './actuatorSetStateCommand';
+export declare class LampSetLightCommand extends ActuatorSetStateCommand {
+    _commandType: CommandType;
+    constructor(source: CommandSource | BaseCommand, on: boolean, reason?: string, timeout?: number);
+    get logMessage(): string;
+}

package/lib/models/command/lampSetLightCommand.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LampSetLightCommand = void 0;
+const commandType_1 = require("./commandType");
+const actuatorSetStateCommand_1 = require("./actuatorSetStateCommand");
+class LampSetLightCommand extends actuatorSetStateCommand_1.ActuatorSetStateCommand {
+    constructor(source, on, reason = '', timeout = -1) {
+        super(source, on, reason, timeout);
+        this._commandType = commandType_1.CommandType.LampSetLightCommand;
+    }
+    get logMessage() {
+        return `Lamp setLight to ${this.on} from ${this.source} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.LampSetLightCommand = LampSetLightCommand;

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

@@ -0,0 +1,18 @@
+import { BaseCommand } from './baseCommand';
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { TimeOfDay } from '../timeCallback';
+export declare class LampSetTimeBasedCommand extends BaseCommand {
+    time: TimeOfDay;
+    timeout: number;
+    _commandType: CommandType;
+    /**
+     * Set's the lamp based on lamp settings for the current time
+     * @param {CommandSource | BaseCommand} source
+     * @param {TimeOfDay} time The time to use for calculation of desired state
+     * @param reason
+     * @param {number} timeout If > 0 this is the time after which the lamp reverts to its original state
+     */
+    constructor(source: CommandSource | BaseCommand, time: TimeOfDay, reason?: string, timeout?: number);
+    get logMessage(): string;
+}

package/lib/models/command/lampSetTimeBasedCommand.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LampSetTimeBasedCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const commandType_1 = require("./commandType");
+const timeCallback_1 = require("../timeCallback");
+class LampSetTimeBasedCommand extends baseCommand_1.BaseCommand {
+    /**
+     * Set's the lamp based on lamp settings for the current time
+     * @param {CommandSource | BaseCommand} source
+     * @param {TimeOfDay} time The time to use for calculation of desired state
+     * @param reason
+     * @param {number} timeout If > 0 this is the time after which the lamp reverts to its original state
+     */
+    constructor(source, time, reason = '', timeout = -1) {
+        super(source, reason);
+        this.time = time;
+        this.timeout = timeout;
+        this._commandType = commandType_1.CommandType.LampSetTimeBasedCommand;
+    }
+    get logMessage() {
+        return `Lamp setTimeBased to ${timeCallback_1.TimeOfDay[this.time]} from ${this.source}`;
+    }
+}
+exports.LampSetTimeBasedCommand = LampSetTimeBasedCommand;

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

@@ -0,0 +1,19 @@
+import { ActuatorToggleCommand } from './actuatorToggleCommand';
+import { CommandType } from './commandType';
+import { CommandSource } from './commandSource';
+import { BaseCommand } from './baseCommand';
+import { TimeOfDay } from '../timeCallback';
+export declare class LampToggleLightCommand extends ActuatorToggleCommand {
+    time?: TimeOfDay | undefined;
+    readonly calculateTime: boolean;
+    _commandType: CommandType;
+    /**
+     *
+     * @param {CommandSource | BaseCommand} source
+     * @param {string} reason
+     * @param {TimeOfDay} time The time to use for calculation of desired state
+     * @param {boolean} calculateTime Alternative to "time", if set the time will be calculated by the lamps room and its settings
+     */
+    constructor(source: CommandSource | BaseCommand, reason?: string, time?: TimeOfDay | undefined, calculateTime?: boolean);
+    get logMessage(): string;
+}

package/lib/models/command/lampToggleLightCommand.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LampToggleLightCommand = void 0;
+const actuatorToggleCommand_1 = require("./actuatorToggleCommand");
+const commandType_1 = require("./commandType");
+class LampToggleLightCommand extends actuatorToggleCommand_1.ActuatorToggleCommand {
+    /**
+     *
+     * @param {CommandSource | BaseCommand} source
+     * @param {string} reason
+     * @param {TimeOfDay} time The time to use for calculation of desired state
+     * @param {boolean} calculateTime Alternative to "time", if set the time will be calculated by the lamps room and its settings
+     */
+    constructor(source, reason = '', time, calculateTime = false) {
+        super(source, reason);
+        this.time = time;
+        this.calculateTime = calculateTime;
+        this._commandType = commandType_1.CommandType.LampToggleLightCommand;
+    }
+    get logMessage() {
+        return `Lamp toggleLight from ${this.source} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.LampToggleLightCommand = LampToggleLightCommand;