hoffmation-base 3.0.2 → 3.1.0

package/lib/api/api-service.js

@@ -0,0 +1,471 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API = void 0;
+const devices_1 = require("../devices");
+const enums_1 = require("../enums");
+const command_1 = require("../command");
+const logging_1 = require("../logging");
+const services_1 = require("../services");
+class API {
+    /**
+     * Endpoint to end a scene manually (or early if it has automatic turn off)
+     * @param deviceId - The id of the scene to end
+     * @returns In case it failed the Error containing the reason
+     */
+    static endScene(deviceId) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.scene)) {
+            return new Error(`Device with ID ${deviceId} is no scene`);
+        }
+        d.log(enums_1.LogLevel.Info, 'API Call to end this.');
+        d.endScene();
+        return null;
+    }
+    /**
+     * Gets the instance of an Ac Device identified by id
+     * @param id - The device id of the AC
+     * @returns The instance of the AC Device or undefined if not found
+     */
+    static getAc(id) {
+        const result = this.getDevice(id);
+        if (!result.deviceCapabilities.includes(enums_1.DeviceCapability.ac)) {
+            return undefined;
+        }
+        return result;
+    }
+    // TODO: Missing Comment
+    static getDevices() {
+        // console.log(Util.inspect(Devices.alLDevices, false, 5));
+        return devices_1.Devices.alLDevices;
+    }
+    // TODO: Missing Comment
+    static getDevice(id, warnIfNotFound = true) {
+        const d = devices_1.Devices.alLDevices[id];
+        if (d === undefined && warnIfNotFound) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `Api.getDevice() --> "${id}" not found`);
+        }
+        return d;
+    }
+    // TODO: Missing Comment
+    static getGroup(id) {
+        const g = services_1.RoomService.Groups.get(id);
+        if (g === undefined) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `Api.getGroup() --> "${id}" not found`);
+        }
+        return g;
+    }
+    // TODO: Missing Comment
+    static getRooms() {
+        // console.log(inspect(Object.fromEntries(RoomService.Rooms)));
+        return services_1.RoomService.Rooms;
+    }
+    // TODO: Missing Comment
+    static getRoom(id) {
+        return services_1.RoomService.Rooms.get(id);
+    }
+    // TODO: Missing Comment
+    static getLog() {
+        return logging_1.ServerLogService.getLog();
+    }
+    /**
+     * Turns on/off one AC identified by it's id
+     * @param id - The id of the device, if wrong false will be returned
+     * @param desiredState - The desired state for the AC
+     * @param desiredMode - The desired mode for the AC
+     * @param desiredTemperature - The desired temperature for the AC in Celsius
+     * @param forceTime - The time in ms this should not change before automatic change is allowed again
+     * @returns True if the AC was found and the state was changed
+     */
+    static setAc(id, desiredState, desiredMode, desiredTemperature, forceTime = 60 * 60 * 1000) {
+        const d = this.getAc(id);
+        if (!d) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `AC Device for id ${id} not found`);
+            return false;
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.ac)) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `Device for id ${id} is not an ac`);
+            return false;
+        }
+        if (desiredMode === undefined) {
+            if (!desiredState) {
+                desiredMode = enums_1.AcMode.Off;
+            }
+            else {
+                desiredMode = d.heatingAllowed ? enums_1.AcMode.Heating : enums_1.AcMode.Cooling;
+            }
+        }
+        d.log(enums_1.LogLevel.Info, `API Call to set AC to ${desiredState} with mode ${desiredMode} for ${forceTime}ms`);
+        d.setState(desiredMode, desiredTemperature, forceTime);
+        return true;
+    }
+    /**
+     * Turns on/off all AC´s in the home
+     * @param desiredState - The desired state for all AC´s
+     */
+    static setAllAc(desiredState) {
+        services_1.DaikinService.setAll(desiredState, true);
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `API Call to set all AC´s to ${desiredState}`);
+    }
+    /**
+     * Changes the status of a given Lamp
+     * @param deviceId - The device Id of the lamp
+     * @param state - The desired new state
+     * @param timeout - Desired time after which this should be reverted to normal state
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.lampSetLight} instead
+     * TODO: Remove deprecated API method
+     */
+    static setLamp(deviceId, state, timeout = 60 * 60 * 1000) {
+        return this.lampSetLight(deviceId, new command_1.LampSetLightCommand(enums_1.CommandSource.API, state, '', new command_1.BlockAutomaticCommand(enums_1.CommandSource.API, timeout)));
+    }
+    /**
+     * Changes the status of a given Lamp
+     * @param deviceId - The device Id of the lamp
+     * @param c - The command(stack) to perform on the lamp
+     * @returns In case it failed the Error containing the reason.
+     */
+    static lampSetLight(deviceId, c) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.lamp)) {
+            return new Error(`Device with ID ${deviceId} is no Lamp`);
+        }
+        d.log(enums_1.LogLevel.Info, 'Received LampSetLightCommand API call.');
+        d.setLight(c);
+        return null;
+    }
+    /**
+     * Changes the status of a given actuator
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - Desired time after which this should be reverted to automatic state
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.actuatorSetState} instead
+     * TODO: Remove deprecated API method
+     */
+    static setActuator(deviceId, state, timeout = 60 * 60 * 1000) {
+        return this.actuatorSetState(deviceId, new command_1.ActuatorSetStateCommand(enums_1.CommandSource.API, state, '', new command_1.BlockAutomaticCommand(enums_1.CommandSource.API, timeout)));
+    }
+    /**
+     * Changes the status of a given actuator
+     * @param deviceId - The device Id of the actuator
+     * @param c - The command(stack) to perform on the actuator
+     * @returns In case it failed the Error containing the reason
+     */
+    static actuatorSetState(deviceId, c) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.actuator)) {
+            return new Error(`Device with ID ${deviceId} is no actuator`);
+        }
+        d.log(enums_1.LogLevel.Info, 'Received ActuatorSetStateCommand API call.');
+        d.setActuator(c);
+        return null;
+    }
+    /**
+     * Changes the status of the given dimmer
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - A chosen Timeout after which the light should be reset
+     * @param brightness - The desired brightness
+     * @param transitionTime - The transition time during turnOn/turnOff
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.dimmerSetLight} instead
+     * TODO: Remove deprecated API method
+     */
+    static setDimmer(deviceId, state, timeout, brightness, transitionTime) {
+        return this.dimmerSetLight(deviceId, new command_1.DimmerSetLightCommand(enums_1.CommandSource.API, state, '', new command_1.BlockAutomaticCommand(enums_1.CommandSource.API, timeout), brightness, transitionTime));
+    }
+    /**
+     * Changes the status of the given dimmer
+     * @param deviceId - The device Id of the dimmable device.
+     * @param command - The command(stack) to perform on the dimmer
+     * @returns In case it failed the Error containing the reason.
+     */
+    static dimmerSetLight(deviceId, command) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.dimmablelamp)) {
+            return new Error(`Device with ID ${deviceId} is no dimmablelamp`);
+        }
+        d.log(enums_1.LogLevel.Info, 'Received dimmerSetLight API call.');
+        d.setLight(command);
+        return null;
+    }
+    /**
+     * Changes the status of a given led-device
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - A chosen Timeout after which the light should be reset
+     * @param brightness - The desired brightness
+     * @param transitionTime - The transition time during turnOn/turnOff
+     * @param color - The desired color in 6 digit hex Code
+     * @param colorTemp - The desired color Temperature (0 = more White)
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.ledSetLight} instead
+     * TODO: Remove deprecated API method
+     */
+    static setLedLamp(deviceId, state, timeout, brightness, transitionTime, color, colorTemp) {
+        return this.ledSetLight(deviceId, new command_1.LedSetLightCommand(enums_1.CommandSource.API, state, '', new command_1.BlockAutomaticCommand(enums_1.CommandSource.API, timeout), brightness, transitionTime, color, colorTemp));
+    }
+    /**
+     * Changes the status of a given led-device
+     * @param deviceId - The device Id of the LED-Device
+     * @param command - The command(stack) to perform on the led-device
+     * @returns In case it failed the Error containing the reason
+     */
+    static ledSetLight(deviceId, command) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.ledLamp)) {
+            return new Error(`Device with ID ${deviceId} is no LED`);
+        }
+        d.log(enums_1.LogLevel.Info, 'Received ledSetLight API call.');
+        d.setLight(command);
+        return null;
+    }
+    /**
+     * Changes the position of a given shutter
+     * if needed this updates the window position as well
+     * @param deviceId - The device Id of the shutter
+     * @param level - The desired new level (0 being open, 100 being closed)
+     * @returns Error if there is no shutter with the given id
+     * @deprecated Use {@link API.shutterSetLevel} instead
+     * TODO: Remove deprecated API method
+     */
+    static setShutter(deviceId, level) {
+        return this.shutterSetLevel(deviceId, new command_1.ShutterSetLevelCommand(enums_1.CommandSource.API, level));
+    }
+    /**
+     * Changes the position of a given shutter
+     * if needed this updates the window position as well
+     * @param deviceId - The device Id of the shutter
+     * @param command - The command(stack) to perform on the shutter
+     * @returns Error if there is no shutter with the given id
+     */
+    static shutterSetLevel(deviceId, command) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.shutter)) {
+            return new Error(`Device with ID ${deviceId} is no Shutter`);
+        }
+        if (d.window) {
+            // otherwise it will be overridden shortly after
+            d.window.setDesiredPosition(new command_1.WindowSetDesiredPositionCommand(command, command.level));
+        }
+        else {
+            d.setLevel(command);
+        }
+        d.log(enums_1.LogLevel.Info, 'Received shutterSetLevel API call.');
+        return null;
+    }
+    // TODO: Missing Comment
+    static speakOnDevice(deviceId, message, volume = 30) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.speaker)) {
+            return new Error(`Device with ID ${deviceId} is no speaker`);
+        }
+        d.log(enums_1.LogLevel.Info, `API Call to speak "${message}" on device with volume ${volume}`);
+        d.speakOnDevice(message, volume);
+        return null;
+    }
+    /**
+     * Starts a specified scene
+     * @param deviceId - The targeted scene
+     * @param turnOffTimeout - If provided the time in ms after which the scene should end automatically
+     * @returns In case it failed the Error containing the reason
+     */
+    static startScene(deviceId, turnOffTimeout) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.scene)) {
+            return new Error(`Device with ID ${deviceId} is no scene`);
+        }
+        d.log(enums_1.LogLevel.Info, 'API Call to start this.');
+        d.startScene(turnOffTimeout);
+        return null;
+    }
+    static switchGarageDoor(deviceId, open) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.garageDoorOpener)) {
+            return new Error(`Device with ID ${deviceId} is no Garage Door Opener`);
+        }
+        if (open) {
+            d.log(enums_1.LogLevel.Info, 'API Call to open Garage Door');
+            d.open();
+        }
+        else {
+            d.log(enums_1.LogLevel.Info, 'API Call to close Garage Door');
+            d.close();
+        }
+        return null;
+    }
+    /**
+     * Changes the settings of a given device
+     * @param deviceId - The id of the device to change the settings
+     * @param settings - A partial settings object containing the wanted settings properties
+     * @returns In case it failed the Error containing the reason
+     */
+    static setDeviceSettings(deviceId, settings) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (d.settings === undefined) {
+            return new Error(`Device with ID ${deviceId} has no settings`);
+        }
+        d.log(enums_1.LogLevel.Info, `API Call to change settings to ${JSON.stringify(settings)})}`);
+        d.settings.fromPartialObject(settings);
+        d.settings.persist(d);
+        return null;
+    }
+    // TODO: Missing Comment
+    static setGroupSettings(groupId, settings) {
+        const g = this.getGroup(groupId);
+        if (g === undefined) {
+            return new Error(`Group with ID ${groupId} not found`);
+        }
+        if (g.settings === undefined) {
+            return new Error(`Group with ID ${groupId} has no settings`);
+        }
+        g.log(enums_1.LogLevel.Info, `API Call to change settings to ${JSON.stringify(settings)})}`);
+        g.settings.fromPartialObject(settings);
+        g.settings.persist(g);
+        return null;
+    }
+    /**
+     * Changes the settings of a given room
+     * @param roomName - The id of the Room to change the settings
+     * @param settings - A partial settings object containing the wanted settings properties
+     * @returns In case it failed the Error containing the reason
+     */
+    static setRoomSettings(roomName, settings) {
+        const r = this.getRoom(roomName);
+        if (r === undefined) {
+            return new Error(`Room with ID ${roomName} not found`);
+        }
+        r.log(enums_1.LogLevel.Info, `API Call to change settings to ${JSON.stringify(settings)})}`);
+        r.settings.settingsContainer.fromPartialObject(settings);
+        r.settings.settingsContainer.persist(r);
+        return null;
+    }
+    // TODO: Missing Comment
+    static getLastCameraImage(deviceId) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.camera)) {
+            return new Error(`Device with ID ${deviceId} is no camera`);
+        }
+        return d.lastImage;
+    }
+    // TODO: Missing Comment
+    static persistAllDeviceSettings() {
+        var _a;
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'API Call to persist all device settings');
+        for (const device of Object.values(devices_1.Devices.alLDevices)) {
+            (_a = device.settings) === null || _a === void 0 ? void 0 : _a.persist(device);
+        }
+    }
+    // TODO: Missing Comment
+    static loadAllDeviceSettingsFromDb() {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'API Call to load all device settings');
+        for (const device of Object.values(devices_1.Devices.alLDevices)) {
+            device.loadDeviceSettings();
+        }
+    }
+    /**
+     * Lifts a previously started Block of automatic
+     * @param deviceId - The target device
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.blockAutomaticLiftAutomaticBlock} instead
+     * TODO: V4 Remove deprecated API method
+     */
+    static liftAutomaticBlock(deviceId) {
+        return this.blockAutomaticLiftAutomaticBlock(deviceId, new command_1.BlockAutomaticLiftBlockCommand(enums_1.CommandSource.API));
+    }
+    /**
+     * Lifts a previously started Block of automatic
+     * @param deviceId - The target device
+     * @param command - The command to lift the automatic block
+     * @returns In case it failed the Error containing the reason
+     */
+    static blockAutomaticLiftAutomaticBlock(deviceId, command) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.blockAutomatic)) {
+            return new Error(`Device with ID ${deviceId} is not capable of blocking automatic`);
+        }
+        d.log(enums_1.LogLevel.Info, 'Received API Call to lift automatic block.');
+        d.blockAutomationHandler.liftAutomaticBlock(command);
+        return null;
+    }
+    /**
+     * Blocks the automatic of the given device for provided Duration
+     * @param deviceId - The target device
+     * @param duration - The duration in ms for which the device should remain in current state
+     * @param onCollision - The desired Collision Solving strategy, in case the automatic being blocked already
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.blockAutomaticSetBlock} instead
+     * TODO: Remove deprecated API method
+     */
+    static blockAutomatic(deviceId, duration, onCollision) {
+        this.blockAutomaticSetBlock(deviceId, new command_1.BlockAutomaticCommand(enums_1.CommandSource.API, duration, '', onCollision));
+        return null;
+    }
+    /**
+     * Blocks the automatic of the given device for provided Duration
+     * @param deviceId - The target device
+     * @param command - The command to block the automatic
+     * @returns In case it failed the Error containing the reason
+     */
+    static blockAutomaticSetBlock(deviceId, command) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.blockAutomatic)) {
+            return new Error(`Device with ID ${deviceId} is not capable of blocking automatic`);
+        }
+        d.log(enums_1.LogLevel.Info, 'Received API Call to block automatic.');
+        d.blockAutomationHandler.disableAutomatic(command);
+        return null;
+    }
+    // TODO: Missing Comment
+    static pressButtonSwitch(deviceId, position, pressType) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.buttonSwitch)) {
+            return new Error(`Device with ID ${deviceId} is no switch`);
+        }
+        d.log(enums_1.LogLevel.Info, `API Call to press button ${position} with ${pressType}`);
+        return d.pressButton(position, pressType);
+    }
+}
+exports.API = API;

package/lib/command/ShutterSetLevelCommand.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from './baseCommand';
+import { CommandSource, CommandType } from '../enums';
+export declare class ShutterSetLevelCommand extends BaseCommand {
+    readonly level: number;
+    readonly skipOpenWarning: boolean;
+    /** @inheritDoc */
+    type: 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/command/ShutterSetLevelCommand.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShutterSetLevelCommand = void 0;
+const baseCommand_1 = require("./baseCommand");
+const enums_1 = require("../enums");
+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.type = enums_1.CommandType.ShutterSetLevelCommand;
+    }
+    get logMessage() {
+        return `Shutter setLevel to ${this.level} for reason: ${this.reasonTrace}`;
+    }
+}
+exports.ShutterSetLevelCommand = ShutterSetLevelCommand;

package/lib/command/WindowRestoreDesiredPositionCommand.d.ts

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

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

package/lib/command/WindowSetDesiredPositionCommand.d.ts

@@ -0,0 +1,16 @@
+import { CommandSource, CommandType } from '../enums';
+import { BaseCommand } from './baseCommand';
+export declare class WindowSetDesiredPositionCommand extends BaseCommand {
+    readonly position: number;
+    readonly applyNewPosition: boolean;
+    /** @inheritDoc */
+    type: 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
+     * @param applyNewPosition - Whether this new position should be applied immediately
+     */
+    constructor(source: CommandSource | BaseCommand, position: number, reason?: string, applyNewPosition?: boolean);
+}

package/lib/command/WindowSetDesiredPositionCommand.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowSetDesiredPositionCommand = void 0;
+const enums_1 = require("../enums");
+const baseCommand_1 = require("./baseCommand");
+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
+     * @param applyNewPosition - Whether this new position should be applied immediately
+     */
+    constructor(source, position, reason = '', applyNewPosition = true) {
+        super(source, reason);
+        this.position = position;
+        this.applyNewPosition = applyNewPosition;
+        /** @inheritDoc */
+        this.type = enums_1.CommandType.WindowSetDesiredPositionCommand;
+    }
+}
+exports.WindowSetDesiredPositionCommand = WindowSetDesiredPositionCommand;

package/lib/command/WindowSetRolloByWeatherStatusCommand.d.ts

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

package/lib/command/WindowSetRolloByWeatherStatusCommand.js

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

package/lib/command/actuatorSetStateCommand.d.ts

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

package/lib/command/actuatorSetStateCommand.js

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