zigbee-herdsman-converters 25.45.0 → 25.47.0

package/dist/lib/bosch.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.boschSmartPlugExtend = exports.boschBsenExtend = exports.boschDoorWindowContactExtend = exports.boschBsirExtend = exports.boschBmctExtend = exports.boschGeneralExtend = exports.manufacturerOptions = void 0;
+exports.boschThermostatExtend = exports.boschSmartPlugExtend = exports.boschWaterAlarmExtend = exports.boschBsenExtend = exports.boschDoorWindowContactExtend = exports.boschBsirExtend = exports.boschBmctExtend = exports.boschGeneralSensorDeviceExtend = exports.boschGeneralEnergyDeviceExtend = exports.boschGeneralExtend = exports.manufacturerOptions = void 0;
 const zigbee_herdsman_1 = require("zigbee-herdsman");
 const fz = __importStar(require("../converters/fromZigbee"));
 const tz = __importStar(require("../converters/toZigbee"));
@@ -47,7 +47,11 @@ const utils_1 = require("./utils");
 const e = exposes.presets;
 const ea = exposes.access;
 const NS = "zhc:bosch";
-exports.manufacturerOptions = { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH };
+exports.manufacturerOptions = {
+    manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+    sendPolicy: "immediate",
+};
+//region Generally used Bosch functionality
 exports.boschGeneralExtend = {
     /** Some devices now use a different name for some custom clusters than
      * originally used. This can lead to issues like those described in
@@ -98,10 +102,20 @@ exports.boschGeneralExtend = {
             isModernExtend: true,
         };
     },
+    /** Some Bosch devices ask the coordinator for their ZCL version
+     * during deviceAnnouncement. Without answer, these devices regularly
+     * re-join the network. To avoid that, we have to make sure that a readRequest
+     * for the zclVersion is always being answered. The answered zclVersion is
+     * taken from the Bosch Smart Home Controller II.
+     *
+     * Exception: BTH-RM and BTH-RM230Z ask the coordinator at regular
+     * intervals for their zclVersion (maybe availability check like Z2M does?)
+     * and *not* during interview! To avoid code-duplication, we handle that
+     * case here as well. */
     handleZclVersionReadRequest: () => {
         const onEvent = [
             (event) => {
-                if (event.type !== "deviceAnnounce") {
+                if (event.type !== "start") {
                     return;
                 }
                 event.data.device.customReadResponse = (frame, endpoint) => {
@@ -124,7 +138,16 @@ exports.boschGeneralExtend = {
             isModernExtend: true,
         };
     },
-    customSeMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
+    batteryWithPercentageAndLowStatus: (args) => m.battery({
+        percentage: true,
+        percentageReportingConfig: false,
+        lowStatus: true,
+        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: null },
+        ...args,
+    }),
+};
+exports.boschGeneralEnergyDeviceExtend = {
+    customMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
         ID: zigbee_herdsman_1.Zcl.Clusters.seMetering.ID,
         attributes: {},
         commands: {
@@ -252,6 +275,118 @@ exports.boschGeneralExtend = {
         };
     },
 };
+exports.boschGeneralSensorDeviceExtend = {
+    customIasZoneCluster: () => m.deviceAddCustomCluster("ssIasZone", {
+        ID: zigbee_herdsman_1.Zcl.Clusters.ssIasZone.ID,
+        attributes: {},
+        commands: {
+            initCustomTestMode: {
+                ID: 0x02,
+                parameters: [
+                    { name: "timeoutInSeconds", type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    { name: "reportTestInZoneStatus", type: zigbee_herdsman_1.Zcl.DataType.ENUM8 },
+                ],
+            },
+        },
+        commandsResponse: {},
+    }),
+    testMode: (args) => {
+        const { testModeDescription, supportTimeout = false } = args;
+        const testModeLookup = {
+            ON: true,
+            OFF: false,
+        };
+        const defaultTimeout = 3;
+        const enableTestMode = async (endpoint, timeout) => {
+            await endpoint.command("ssIasZone", "initCustomTestMode", {
+                timeoutInSeconds: timeout,
+                reportTestInZoneStatus: 0x80,
+            });
+        };
+        const disableTestMode = async (endpoint) => {
+            await endpoint.command("ssIasZone", "initNormalOpMode", {});
+        };
+        const exposes = [
+            e
+                .binary("test_mode", ea.ALL, utils.getFromLookupByValue(true, testModeLookup), utils.getFromLookupByValue(false, testModeLookup))
+                .withDescription(testModeDescription)
+                .withCategory("config"),
+        ];
+        if (supportTimeout) {
+            exposes.push(e
+                .numeric("test_mode_timeout", ea.ALL)
+                .withDescription(`Determines how long the test mode should be activated. The default length is ${defaultTimeout} seconds.`)
+                .withValueMin(1)
+                .withValueMax(255)
+                .withUnit("seconds")
+                .withCategory("config"));
+        }
+        const fromZigbee = [
+            {
+                cluster: "ssIasZone",
+                type: ["commandStatusChangeNotification", "attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const zoneStatus = "zonestatus" in msg.data ? msg.data.zonestatus : msg.data.zoneStatus;
+                    if (zoneStatus === undefined) {
+                        return;
+                    }
+                    const result = {};
+                    const testModeEnabled = (zoneStatus & (1 << 8)) > 0;
+                    result.test_mode = utils.getFromLookupByValue(testModeEnabled, testModeLookup);
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["test_mode", "test_mode_timeout"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (key === "test_mode") {
+                        if (value === utils.getFromLookupByValue(true, testModeLookup)) {
+                            let timeout;
+                            if (supportTimeout) {
+                                const currentTimeout = meta.state.test_mode_timeout;
+                                if (currentTimeout == null) {
+                                    timeout = defaultTimeout;
+                                    meta.publish({ test_mode_timeout: timeout });
+                                }
+                                else {
+                                    timeout = utils.toNumber(currentTimeout);
+                                }
+                            }
+                            else {
+                                timeout = 0;
+                            }
+                            await enableTestMode(entity, timeout);
+                        }
+                        else {
+                            await disableTestMode(entity);
+                        }
+                    }
+                    if (key === "test_mode_timeout") {
+                        return { state: { test_mode_timeout: value } };
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    if (key === "test_mode") {
+                        await entity.read("ssIasZone", ["zoneStatus"]);
+                    }
+                    if (key === "test_mode_timeout" && meta.state.test_mode_timeout == null) {
+                        meta.publish({ test_mode_timeout: supportTimeout ? defaultTimeout : 0 });
+                    }
+                },
+            },
+        ];
+        const configure = [m.setupConfigureForBinding("ssIasZone", "input"), m.setupConfigureForReading("ssIasZone", ["zoneStatus"])];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+};
 exports.boschBmctExtend = {
     switchMode: (args) => {
         const { endpoint, deviceModeLookup, switchModeLookup, switchTypeLookup } = args;
@@ -1183,20 +1318,6 @@ exports.boschBsirExtend = {
         },
         access: "STATE_GET",
     }),
-    battery: () => m.battery({
-        percentage: true,
-        percentageReportingConfig: {
-            min: "MIN",
-            max: "MAX",
-            change: 1,
-        },
-        lowStatus: true,
-        lowStatusReportingConfig: {
-            min: "MIN",
-            max: "MAX",
-            change: 0,
-        },
-    }),
     lightDelay: () => m.numeric({
         name: "light_delay",
         cluster: "ssIasWd",
@@ -1415,11 +1536,6 @@ exports.boschDoorWindowContactExtend = {
         commands: {},
         commandsResponse: {},
     }),
-    battery: () => m.battery({
-        percentage: true,
-        lowStatus: true,
-        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: 0 },
-    }),
     reportContactState: () => m.iasZoneAlarm({
         zoneType: "contact",
         zoneAttributes: ["alarm_1"],
@@ -1693,18 +1809,9 @@ exports.boschDoorWindowContactExtend = {
         };
     },
 };
+//endregion
+//region Bosch BSEN-M device (Motion detector)
 exports.boschBsenExtend = {
-    customIasZoneCluster: () => m.deviceAddCustomCluster("ssIasZone", {
-        ID: zigbee_herdsman_1.Zcl.Clusters.ssIasZone.ID,
-        attributes: {},
-        commands: {
-            initCustomTestMode: {
-                ID: 0x02,
-                parameters: [{ name: "data", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.LIST_UINT8 }],
-            },
-        },
-        commandsResponse: {},
-    }),
     battery: () => m.battery({
         percentage: false,
         percentageReporting: false,
@@ -1712,7 +1819,12 @@ exports.boschBsenExtend = {
         voltageReporting: true,
         voltageToPercentage: { min: 2500, max: 3000 },
         lowStatus: true,
-        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: 0 },
+        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: null },
+    }),
+    testMode: () => exports.boschGeneralSensorDeviceExtend.testMode({
+        testModeDescription: "Activates the test mode. In this mode, the device blinks on every detected motion " +
+            "without any wait time in between to verify the installation. Please keep in mind " +
+            "that it can take up to 45 seconds for the test mode to be activated.",
     }),
     illuminance: () => m.illuminance({ reporting: { min: "1_SECOND", max: 600, change: 3522 } }),
     // The temperature sensor isn't used at all by Bosch on the BSEN-M.
@@ -1867,26 +1979,101 @@ exports.boschBsenExtend = {
             isModernExtend: true,
         };
     },
-    testMode: () => {
-        const testModeLookup = {
-            ON: true,
-            OFF: false,
+};
+exports.boschWaterAlarmExtend = {
+    waterAlarmCluster: () => m.deviceAddCustomCluster("boschWaterAlarm", {
+        ID: 0xfcac,
+        manufacturerCode: exports.manufacturerOptions.manufacturerCode,
+        attributes: {
+            alarmOnMotion: { ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+        },
+        commands: {
+            muteAlarmControl: { ID: 0x00, parameters: [{ name: "data", type: zigbee_herdsman_1.Zcl.DataType.UINT8 }] },
+            muteAlarmControlResponse: { ID: 0x01, parameters: [{ name: "data", type: zigbee_herdsman_1.Zcl.DataType.ENUM8 }] },
+        },
+        commandsResponse: {},
+    }),
+    changedSensitivityLevel: () => {
+        const configure = [
+            m.setupConfigureForBinding("ssIasZone", "input"),
+            m.setupConfigureForReading("ssIasZone", ["numZoneSensitivityLevelsSupported", "currentZoneSensitivityLevel"]),
+            async (device, coordinatorEndpoint, definition) => {
+                const endpoint = device.getEndpoint(1);
+                // The write request is made when using the proprietary
+                // Bosch Smart Home Controller II as of 16-10-2025. Looks like
+                // the default value was too high, and they didn't want to
+                // push a firmware update. We mimic it here to avoid complaints.
+                await endpoint.write("ssIasZone", { currentZoneSensitivityLevel: 5 });
+            },
+        ];
+        return {
+            configure,
+            isModernExtend: true,
         };
-        const enableTestMode = async (endpoint) => {
-            await endpoint.command("ssIasZone", "initCustomTestMode", {
-                data: [0x00, 0x80],
-            });
+    },
+    waterAndTamperAlarm: () => m.iasZoneAlarm({
+        zoneType: "water_leak",
+        zoneAttributes: ["alarm_1", "tamper"],
+    }),
+    muteAlarmControl: () => {
+        const muteAlarmControlLookup = {
+            UNMUTED: false,
+            MUTED: true,
         };
-        const disableTestMode = async (endpoint) => {
-            await endpoint.command("ssIasZone", "initNormalOpMode", {});
+        const muteAlarmControlResponseLookup = {
+            muted: 0x00,
+            error: 0x01,
+            no_change: 0x02,
+            unmuted: 0x03,
         };
         const exposes = [
             e
-                .binary("test_mode", ea.ALL, utils.getFromLookupByValue(true, testModeLookup), utils.getFromLookupByValue(false, testModeLookup))
-                .withDescription("Activate the test mode. In this mode, the device blinks on every detected motion without any wait time in between to verify the installation. Please keep in mind that it can take up to 45 seconds for the test mode to be activated.")
-                .withCategory("config"),
+                .binary("water_leak_alarm_control", ea.ALL, utils.getFromLookupByValue(true, muteAlarmControlLookup), utils.getFromLookupByValue(false, muteAlarmControlLookup))
+                .withLabel("Mute water leak alarm")
+                .withDescription("In case of an water leak, you can mute and unmute the audible alarm here"),
+        ];
+        const toZigbee = [
+            {
+                key: ["water_leak_alarm_control"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (value === utils.getFromLookupByValue(false, muteAlarmControlLookup)) {
+                        await entity.command("boschWaterAlarm", "muteAlarmControl", { data: 0x00 }, exports.manufacturerOptions);
+                    }
+                    else {
+                        await entity.command("boschWaterAlarm", "muteAlarmControl", { data: 0x01 }, exports.manufacturerOptions);
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("ssIasZone", ["zoneStatus"]);
+                },
+            },
         ];
         const fromZigbee = [
+            {
+                cluster: "boschWaterAlarm",
+                type: ["raw"],
+                convert: (model, msg, publish, options, meta) => {
+                    const command = msg.data[4];
+                    if (command !== 0x01) {
+                        return;
+                    }
+                    const muteAlarmControlResponse = msg.data[5];
+                    switch (muteAlarmControlResponse) {
+                        case muteAlarmControlResponseLookup.muted:
+                            logger_1.logger.debug(`Alarm on device '${meta.device.ieeeAddr}' was muted`, NS);
+                            break;
+                        case muteAlarmControlResponseLookup.error:
+                            logger_1.logger.error(`Alarm on device '${meta.device.ieeeAddr}' could not be muted right now (e.g., no active alarm)!`, NS);
+                            break;
+                        case muteAlarmControlResponseLookup.no_change:
+                            logger_1.logger.debug(`Alarm on device '${meta.device.ieeeAddr}' is already in requested state`, NS);
+                            break;
+                        case muteAlarmControlResponseLookup.unmuted:
+                            logger_1.logger.debug(`Alarm on device '${meta.device.ieeeAddr}' was unmuted`, NS);
+                            break;
+                    }
+                },
+            },
             {
                 cluster: "ssIasZone",
                 type: ["commandStatusChangeNotification", "attributeReport", "readResponse"],
@@ -1896,39 +2083,36 @@ exports.boschBsenExtend = {
                         return;
                     }
                     const result = {};
-                    const testModeEnabled = (zoneStatus & (1 << 8)) > 0;
-                    result.test_mode = utils.getFromLookupByValue(testModeEnabled, testModeLookup);
+                    const alarmMuted = (zoneStatus & (1 << 1)) > 0;
+                    result.water_leak_alarm_control = utils.getFromLookupByValue(alarmMuted, muteAlarmControlLookup);
                     return result;
                 },
             },
         ];
-        const toZigbee = [
-            {
-                key: ["test_mode"],
-                convertSet: async (entity, key, value, meta) => {
-                    if (key === "test_mode") {
-                        if (value === utils.getFromLookupByValue(true, testModeLookup)) {
-                            await enableTestMode(entity);
-                        }
-                        else {
-                            await disableTestMode(entity);
-                        }
-                    }
-                },
-                convertGet: async (entity, key, meta) => {
-                    await entity.read("ssIasZone", ["zoneStatus"]);
-                },
-            },
-        ];
         const configure = [m.setupConfigureForBinding("ssIasZone", "input"), m.setupConfigureForReading("ssIasZone", ["zoneStatus"])];
         return {
             exposes,
-            fromZigbee,
             toZigbee,
+            fromZigbee,
             configure,
             isModernExtend: true,
         };
     },
+    alarmOnMotion: () => m.binary({
+        name: "alarm_on_motion",
+        cluster: "boschWaterAlarm",
+        attribute: "alarmOnMotion",
+        description: "If your water alarm is moved, an acoustic signal sounds",
+        valueOn: ["ON", 0x01],
+        valueOff: ["OFF", 0x00],
+        entityCategory: "config",
+    }),
+    testMode: () => exports.boschGeneralSensorDeviceExtend.testMode({
+        testModeDescription: "Activates the test mode. In this mode, the device acts like it would when " +
+            "detecting any water to verify the installation. Please keep in mind " +
+            "that it can take up to 10 seconds for the test mode to be activated.",
+        supportTimeout: true,
+    }),
 };
 exports.boschSmartPlugExtend = {
     smartPlugCluster: () => m.deviceAddCustomCluster("boschEnergyDevice", {
@@ -2068,5 +2252,735 @@ exports.boschSmartPlugExtend = {
         ...args,
     }),
 };
+const boschThermostatLookup = {
+    systemModes: {
+        heat: 0x04,
+        cool: 0x03,
+    },
+    raRunningStates: ["idle", "heat"],
+    heaterType: {
+        underfloor_heating: 0x00,
+        radiator: 0x02,
+        central_heating: 0x01,
+        manual_control: 0x03,
+    },
+};
+exports.boschThermostatExtend = {
+    customThermostatCluster: () => m.deviceAddCustomCluster("hvacThermostat", {
+        ID: zigbee_herdsman_1.Zcl.Clusters.hvacThermostat.ID,
+        attributes: {
+            operatingMode: { ID: 0x4007, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            heatingDemand: { ID: 0x4020, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            valveAdaptStatus: { ID: 0x4022, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            unknownAttribute0: { ID: 0x4025, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            remoteTemperature: { ID: 0x4040, type: zigbee_herdsman_1.Zcl.DataType.INT16, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            unknownAttribute1: { ID: 0x4041, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            windowOpenMode: { ID: 0x4042, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            boostHeating: { ID: 0x4043, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            cableSensorTemperature: { ID: 0x4052, type: zigbee_herdsman_1.Zcl.DataType.INT16, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            valveType: { ID: 0x4060, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            unknownAttribute2: { ID: 0x4061, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            cableSensorMode: { ID: 0x4062, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            heaterType: { ID: 0x4063, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            errorState: { ID: 0x5000, type: zigbee_herdsman_1.Zcl.DataType.BITMAP8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            automaticValveAdapt: { ID: 0x5010, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+        },
+        commands: {
+            calibrateValve: { ID: 0x41, parameters: [] },
+        },
+        commandsResponse: {},
+    }),
+    customUserInterfaceCfgCluster: () => m.deviceAddCustomCluster("hvacUserInterfaceCfg", {
+        ID: zigbee_herdsman_1.Zcl.Clusters.hvacUserInterfaceCfg.ID,
+        attributes: {
+            displayOrientation: { ID: 0x400b, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            activityLed: { ID: 0x4033, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            displayedTemperature: { ID: 0x4039, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            displaySwitchOnDuration: { ID: 0x403a, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            displayBrightness: { ID: 0x403b, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    relayState: () => m.onOff({ description: "The state of the relay controlling the connected heating/cooling device", powerOnBehavior: false }),
+    cableSensorMode: () => m.enumLookup({
+        name: "cable_sensor_mode",
+        cluster: "hvacThermostat",
+        attribute: "cableSensorMode",
+        description: 'Select a configuration for the sensor connection. If you select "with_regulation", ' +
+            "the measured temperature on the cable sensor is used by the heating/cooling algorithm " +
+            "instead of the local temperature.",
+        lookup: { not_used: 0x00, cable_sensor_without_regulation: 0xb0, cable_sensor_with_regulation: 0xb1 },
+        reporting: false,
+        entityCategory: "config",
+    }),
+    cableSensorTemperature: () => m.numeric({
+        name: "cable_sensor_temperature",
+        cluster: "hvacThermostat",
+        attribute: "cableSensorTemperature",
+        description: "Measured temperature value on the cable sensor (if enabled)",
+        unit: "°C",
+        scale: 100,
+        reporting: { min: 30, max: "MAX", change: 20 },
+        access: "STATE_GET",
+    }),
+    heaterType: () => m.enumLookup({
+        name: "heater_type",
+        cluster: "hvacThermostat",
+        attribute: "heaterType",
+        description: "Select the connected heater type or 'manual_control' if you like to activate the relay manually when necessary",
+        lookup: boschThermostatLookup.heaterType,
+        reporting: false,
+        entityCategory: "config",
+    }),
+    valveType: () => m.enumLookup({
+        name: "valve_type",
+        cluster: "hvacThermostat",
+        attribute: "valveType",
+        description: "Select the connected valve type",
+        lookup: { normally_closed: 0x00, normally_open: 0x01 },
+        reporting: false,
+        entityCategory: "config",
+    }),
+    humidity: () => m.humidity({ reporting: false }),
+    windowOpenMode: (args) => m.binary({
+        name: "window_open_mode",
+        cluster: "hvacThermostat",
+        attribute: "windowOpenMode",
+        description: "Activates the window open mode, where the thermostat disables any heating/cooling " +
+            "to prevent unnecessary energy consumption. Please keep in mind that the device " +
+            "itself does not detect any open windows!",
+        valueOn: ["ON", 0x01],
+        valueOff: ["OFF", 0x00],
+        reporting: args?.enableReporting ? { min: "MIN", max: "MAX", change: null } : false,
+    }),
+    childLock: () => m.binary({
+        name: "child_lock",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "keypadLockout",
+        description: "Enables/disables physical input on the thermostat",
+        valueOn: ["LOCK", 0x01],
+        valueOff: ["UNLOCK", 0x00],
+        reporting: { min: "MIN", max: "MAX", change: null },
+    }),
+    displayBrightness: () => m.numeric({
+        name: "display_brightness",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "displayBrightness",
+        description: "Sets brightness of the display",
+        valueMin: 0,
+        valueMax: 100,
+        valueStep: 10,
+        unit: "%",
+        scale: 0.1,
+        reporting: false,
+        entityCategory: "config",
+    }),
+    displaySwitchOnDuration: () => m.numeric({
+        name: "display_switch_on_duration",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "displaySwitchOnDuration",
+        label: "Display switch-on duration",
+        description: "Sets the time before the display is automatically switched off",
+        valueMin: 5,
+        valueMax: 30,
+        unit: "s",
+        reporting: false,
+        entityCategory: "config",
+    }),
+    displayOrientation: () => m.enumLookup({
+        name: "display_orientation",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "displayOrientation",
+        description: "You can rotate the display content by 180° here. This is recommended if your thermostat is fitted vertically, for instance.",
+        lookup: { standard_arrangement: 0x00, rotated_by_180_degrees: 0x01 },
+        reporting: false,
+        entityCategory: "config",
+    }),
+    displayedTemperature: () => m.enumLookup({
+        name: "displayed_temperature",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "displayedTemperature",
+        description: "Select which temperature should be displayed on your radiator thermostat display",
+        lookup: { set_temperature: 0x00, measured_temperature: 0x01 },
+        reporting: false,
+        entityCategory: "config",
+    }),
+    activityLedState: () => m.enumLookup({
+        name: "activity_led",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "activityLed",
+        label: "Activity LED state",
+        description: "Determines the state of the little dot on the display next to the heating/cooling symbol",
+        lookup: { off: 0x00, auto: 0x01, on: 0x02 },
+        reporting: false,
+        entityCategory: "config",
+    }),
+    remoteTemperature: () => m.numeric({
+        name: "remote_temperature",
+        cluster: "hvacThermostat",
+        attribute: "remoteTemperature",
+        description: "Input for remote temperature sensor. Required at least every 30 minutes to prevent fallback to the internal sensor!",
+        valueMin: 0.0,
+        valueMax: 35.0,
+        valueStep: 0.2,
+        unit: "°C",
+        scale: 100,
+        reporting: false,
+        entityCategory: "config",
+    }),
+    setpointChangeSource: (args) => m.enumLookup({
+        name: "setpoint_change_source",
+        cluster: "hvacThermostat",
+        attribute: "setpointChangeSource",
+        description: "Source of the current setpoint temperature",
+        lookup: { manual: 0x00, schedule: 0x01, externally: 0x02 },
+        access: "STATE_GET",
+        reporting: args?.enableReporting ? { min: "MIN", max: "MAX", change: null } : false,
+        entityCategory: "diagnostic",
+    }),
+    customHeatingDemand: () => m.numeric({
+        name: "pi_heating_demand",
+        cluster: "hvacThermostat",
+        attribute: "heatingDemand",
+        label: "PI heating demand",
+        description: "Position of the valve (= demanded heat) where 0% is fully closed and 100% is fully open",
+        unit: "%",
+        valueMin: 0,
+        valueMax: 100,
+        access: "ALL",
+        reporting: { min: "MIN", max: "MAX", change: null },
+    }),
+    rmBattery: () => m.battery({
+        percentage: true,
+        percentageReporting: false,
+        voltage: true,
+        voltageReporting: true,
+        voltageReportingConfig: false,
+        voltageToPercentage: { min: 4400, max: 6400 },
+        lowStatus: true,
+        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: null },
+    }),
+    rmThermostat: () => {
+        const thermostat = m.thermostat({
+            localTemperature: {
+                configure: { reporting: false },
+            },
+            localTemperatureCalibration: {
+                values: { min: -5, max: 5, step: 0.1 },
+                configure: { reporting: false },
+            },
+            setpoints: {
+                values: {
+                    occupiedHeatingSetpoint: { min: 5, max: 30, step: 0.5 },
+                    occupiedCoolingSetpoint: { min: 5, max: 30, step: 0.5 },
+                },
+                configure: { reporting: false },
+            },
+            systemMode: {
+                values: ["heat", "cool"],
+                toZigbee: { skip: true },
+                configure: { skip: true },
+            },
+            runningState: {
+                values: ["idle", "heat", "cool"],
+                configure: { reporting: false },
+            },
+        });
+        const expose = (device, options) => {
+            const returnedThermostat = thermostat.exposes;
+            if (utils.isDummyDevice(device)) {
+                return returnedThermostat;
+            }
+            let currentSystemMode;
+            try {
+                currentSystemMode = utils.getFromLookupByValue(device.getEndpoint(1).getClusterAttributeValue("hvacThermostat", "systemMode"), boschThermostatLookup.systemModes);
+            }
+            catch {
+                currentSystemMode = "heat";
+            }
+            // The thermostat is a singleton, thus the values must be set
+            // manually as filtering will lead to an array without
+            // heat/cool in them after two systemMode changes.
+            returnedThermostat[0].features.forEach((exposedAttribute, index, array) => {
+                if (exposedAttribute.type === "enum") {
+                    if (exposedAttribute.name === "system_mode") {
+                        exposedAttribute.label = "Active system mode";
+                        exposedAttribute.description =
+                            "Currently used system mode by the thermostat. This field is primarily " +
+                                "used to configure the thermostat in Home Assistant correctly.";
+                        exposedAttribute.values = [currentSystemMode];
+                        exposedAttribute.access = ea.STATE;
+                    }
+                    if (exposedAttribute.name === "running_state") {
+                        exposedAttribute.values = ["idle", currentSystemMode];
+                    }
+                }
+            });
+            return returnedThermostat;
+        };
+        return {
+            exposes: [expose],
+            fromZigbee: thermostat.fromZigbee,
+            toZigbee: thermostat.toZigbee,
+            configure: thermostat.configure,
+            isModernExtend: true,
+        };
+    },
+    customSystemMode: () => {
+        const exposes = [
+            e
+                .enum("custom_system_mode", ea.ALL, Object.keys(boschThermostatLookup.systemModes))
+                .withLabel("Available system modes")
+                .withDescription("Select if the thermostat is connected to a heating or a cooling device")
+                .withCategory("config"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "hvacThermostat",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.systemMode !== undefined) {
+                        result.custom_system_mode = utils.getFromLookupByValue(data.systemMode, boschThermostatLookup.systemModes);
+                        meta.deviceExposesChanged();
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["custom_system_mode"],
+                convertSet: async (entity, key, value, meta) => {
+                    await entity.write("hvacThermostat", {
+                        systemMode: utils.toNumber(utils.getFromLookup(value, boschThermostatLookup.systemModes)),
+                    });
+                    return { state: { custom_system_mode: value } };
+                },
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("hvacThermostat", ["systemMode"]);
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForReporting("hvacThermostat", "systemMode", {
+                config: false,
+                access: ea.ALL,
+            }),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    raThermostat: () => {
+        // Native thermostat
+        const thermostat = m.thermostat({
+            localTemperature: {
+                values: {
+                    description: "Temperature used by the heating algorithm. This is the " +
+                        "temperature measured on the device (by default) or the " +
+                        "remote temperature (if set within the last 30 min).",
+                },
+                configure: {
+                    reporting: { min: 30, max: 900, change: 20 },
+                },
+            },
+            localTemperatureCalibration: {
+                values: { min: -5, max: 5, step: 0.1 },
+                configure: { reporting: false },
+            },
+            setpoints: {
+                values: {
+                    occupiedHeatingSetpoint: { min: 5, max: 30, step: 0.5 },
+                },
+                configure: {
+                    reporting: { min: "MIN", max: "MAX", change: 1 },
+                },
+            },
+            systemMode: {
+                values: ["heat"],
+                configure: {
+                    reporting: false,
+                },
+            },
+            runningState: {
+                values: boschThermostatLookup.raRunningStates,
+                toZigbee: {
+                    skip: true,
+                },
+                configure: {
+                    reporting: false,
+                },
+            },
+            piHeatingDemand: {
+                values: ea.ALL,
+                toZigbee: {
+                    skip: true,
+                },
+                configure: {
+                    skip: true,
+                },
+            },
+        });
+        const exposes = thermostat.exposes;
+        const fromZigbee = thermostat.fromZigbee;
+        const toZigbee = thermostat.toZigbee;
+        let configure = thermostat.configure;
+        // Add converters for custom running state
+        const runningState = exports.boschThermostatExtend.customRunningState();
+        fromZigbee.push(...runningState.fromZigbee);
+        toZigbee.push(...runningState.toZigbee);
+        // Add converters and configure for custom heating demand
+        const piHeatingDemand = exports.boschThermostatExtend.customHeatingDemand();
+        fromZigbee.push(...piHeatingDemand.fromZigbee);
+        toZigbee.push(...piHeatingDemand.toZigbee);
+        configure = [...configure, ...piHeatingDemand.configure];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    customRunningState: () => {
+        const fromZigbee = [
+            {
+                cluster: "hvacThermostat",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.heatingDemand !== undefined) {
+                        result.running_state =
+                            utils.toNumber(data.heatingDemand) > 0
+                                ? boschThermostatLookup.raRunningStates[1]
+                                : boschThermostatLookup.raRunningStates[0];
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["running_state"],
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("hvacThermostat", ["heatingDemand"]);
+                },
+            },
+        ];
+        return {
+            fromZigbee,
+            toZigbee,
+            isModernExtend: true,
+        };
+    },
+    operatingMode: (args) => {
+        const operatingModeLookup = { schedule: 0x00, manual: 0x01, pause: 0x05 };
+        const operatingMode = m.enumLookup({
+            name: "operating_mode",
+            cluster: "hvacThermostat",
+            attribute: "operatingMode",
+            description: "Bosch-specific operating mode. This is being used as mode on the exposed thermostat when using Home Assistant.",
+            lookup: operatingModeLookup,
+            reporting: args?.enableReporting ? { min: "MIN", max: "MAX", change: null } : false,
+            entityCategory: "config",
+        });
+        const exposes = operatingMode.exposes;
+        const fromZigbee = operatingMode.fromZigbee;
+        const toZigbee = operatingMode.toZigbee;
+        const configure = operatingMode.configure;
+        const removeLowAndHighTemperatureFields = (payload) => {
+            payload.temperature_high_command_topic = undefined;
+            payload.temperature_low_command_topic = undefined;
+            payload.temperature_high_state_template = undefined;
+            payload.temperature_low_state_template = undefined;
+            payload.temperature_high_state_topic = undefined;
+            payload.temperature_low_state_topic = undefined;
+        };
+        // Override the payload send to Home Assistant to achieve the following:
+        // 1. Use the Bosch operating mode instead of system modes
+        //    See: https://github.com/Koenkk/zigbee2mqtt/pull/23075#issue-2355829475
+        // 2. Remove setpoints not compatible with the currently used system mode
+        //    See: https://github.com/Koenkk/zigbee2mqtt/issues/28892
+        const meta = {
+            overrideHaDiscoveryPayload: (payload) => {
+                if (payload.modes !== undefined) {
+                    if (payload.modes.includes("heat")) {
+                        payload.mode_command_template =
+                            `{% set values = { 'auto':'schedule', 'heat':'manual', 'off':'pause' } %}` +
+                                `{"operating_mode": "{{ values[value] if value in values.keys() else 'pause' }}"}`;
+                        payload.mode_state_template =
+                            `{% set values = { 'schedule':'auto', 'manual':'heat', 'pause':'off' } %}` +
+                                "{% set value = value_json.operating_mode %}" +
+                                `{{ values[value] if value in values.keys() else 'off' }}`;
+                        if (payload.temperature_low_command_topic !== undefined) {
+                            payload.temperature_command_topic = payload.temperature_low_command_topic;
+                            payload.temperature_state_template = payload.temperature_low_state_template;
+                            payload.temperature_state_topic = payload.temperature_low_state_topic;
+                            removeLowAndHighTemperatureFields(payload);
+                        }
+                    }
+                    else if (payload.modes.includes("cool")) {
+                        payload.mode_command_template =
+                            `{% set values = { 'auto':'schedule', 'cool':'manual', 'off':'pause' } %}` +
+                                `{"operating_mode": "{{ values[value] if value in values.keys() else 'pause' }}"}`;
+                        payload.mode_state_template =
+                            `{% set values = { 'schedule':'auto', 'manual':'cool', 'pause':'off' } %}` +
+                                "{% set value = value_json.operating_mode %}" +
+                                `{{ values[value] if value in values.keys() else 'off' }}`;
+                        if (payload.temperature_high_command_topic !== undefined) {
+                            payload.temperature_command_topic = payload.temperature_high_command_topic;
+                            payload.temperature_state_template = payload.temperature_high_state_template;
+                            payload.temperature_state_topic = payload.temperature_high_state_topic;
+                            removeLowAndHighTemperatureFields(payload);
+                        }
+                    }
+                    payload.modes = ["off", ...payload.modes, "auto"];
+                    payload.mode_command_topic = payload.mode_command_topic.replace("/system_mode", "");
+                }
+            },
+        };
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            meta,
+            isModernExtend: true,
+        };
+    },
+    boostHeating: (args) => {
+        const boostHeatingLookup = {
+            OFF: 0x00,
+            ON: 0x01,
+        };
+        const exposes = [
+            e
+                .binary("boost_heating", ea.ALL, utils.getFromLookupByValue(0x01, boostHeatingLookup), utils.getFromLookupByValue(0x00, boostHeatingLookup))
+                .withLabel("Activate boost heating")
+                .withDescription("Activate boost heating (opens TRV for 5 minutes)"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "hvacThermostat",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.boostHeating !== undefined) {
+                        result.boost_heating = utils.getFromLookupByValue(data.boostHeating, boostHeatingLookup);
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["boost_heating"],
+                convertSet: async (entity, key, value, meta) => {
+                    const enableBoostHeating = value === utils.getFromLookupByValue(boostHeatingLookup.ON, boostHeatingLookup);
+                    if (enableBoostHeating) {
+                        const systemModeNotSetToHeat = "system_mode" in meta.state && meta.state.system_mode !== "heat";
+                        if (systemModeNotSetToHeat) {
+                            throw new Error("Boost heating is only possible when system mode is set to 'heat'!");
+                        }
+                        const heaterTypeNotSetToRadiator = "heater_type" in meta.state &&
+                            meta.state.heater_type !==
+                                utils.getFromLookupByValue(boschThermostatLookup.heaterType.radiator, boschThermostatLookup.heaterType);
+                        if (heaterTypeNotSetToRadiator) {
+                            throw new Error("Boost heating is only possible when heater type is set to 'radiator'!");
+                        }
+                    }
+                    await entity.write("hvacThermostat", {
+                        boostHeating: utils.toNumber(utils.getFromLookup(value, boostHeatingLookup)),
+                    });
+                    return { state: { boost_heating: value } };
+                },
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("hvacThermostat", ["boostHeating"]);
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForReporting("hvacThermostat", "boostHeating", {
+                config: args?.enableReporting ? { min: "MIN", max: "MAX", change: null } : false,
+                access: ea.ALL,
+            }),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    errorState: (args) => {
+        const exposes = [
+            e
+                .text("error_state", ea.STATE_GET)
+                .withDescription("Indicates whether the device encounters any errors or not")
+                .withCategory("diagnostic"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "hvacThermostat",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.errorState !== undefined) {
+                        const receivedErrorState = data.errorState;
+                        if (receivedErrorState === 0) {
+                            result.error_state = "ok";
+                        }
+                        else {
+                            result.error_state = "";
+                            const bitmapLength = (receivedErrorState >>> 0).toString(2).length;
+                            for (let errorNumber = 0; errorNumber < bitmapLength; errorNumber++) {
+                                if ((receivedErrorState >> errorNumber) & 1) {
+                                    if (String(result.error_state).length > 0) {
+                                        result.error_state += " - ";
+                                    }
+                                    result.error_state += `E${String(errorNumber + 1).padStart(2, "0")}`;
+                                }
+                            }
+                        }
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["error_state"],
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("hvacThermostat", ["errorState"]);
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForReporting("hvacThermostat", "errorState", {
+                config: args?.enableReporting ? { min: "MIN", max: "MAX", change: null } : false,
+                access: ea.STATE_GET,
+            }),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    valveAdaptation: () => {
+        const valveAdaptStatusLookup = {
+            none: 0x00,
+            ready_to_calibrate: 0x01,
+            calibration_in_progress: 0x02,
+            error: 0x03,
+            success: 0x04,
+        };
+        const triggerValveAdaptation = async (state, endpoint, throwError = true) => {
+            let adaptStatus;
+            try {
+                adaptStatus = utils.getFromLookup(state.valve_adapt_status, valveAdaptStatusLookup);
+            }
+            catch {
+                adaptStatus = valveAdaptStatusLookup.none;
+            }
+            switch (adaptStatus) {
+                case valveAdaptStatusLookup.ready_to_calibrate:
+                case valveAdaptStatusLookup.error:
+                    await endpoint.command("hvacThermostat", "calibrateValve", {}, exports.manufacturerOptions);
+                    break;
+                default:
+                    if (throwError) {
+                        throw new Error("Valve adaptation process not possible right now!");
+                    }
+            }
+        };
+        const exposes = [
+            e
+                .enum("valve_adapt_status", ea.STATE_GET, Object.keys(valveAdaptStatusLookup))
+                .withLabel("Valve adaptation status")
+                .withDescription("Specifies the current status of the valve adaptation")
+                .withCategory("diagnostic"),
+            e
+                .binary("automatic_valve_adapt", ea.STATE_GET, true, false)
+                .withLabel("Automatic valve adaptation requested")
+                .withDescription("Specifies if an automatic valve adaptation is being requested by the thermostat " +
+                "(for example after a successful firmware upgrade). If this is the case, the " +
+                "valve adaptation will be automatically started as soon as the adaptation status " +
+                "is 'ready_to_calibrate' or 'error'.")
+                .withCategory("diagnostic"),
+            e
+                .enum("valve_adapt_process", ea.SET, ["adapt"])
+                .withLabel("Trigger adaptation process")
+                .withDescription("Trigger the valve adaptation process. Only possible when the adaptation status is 'ready_to_calibrate' or 'error'.")
+                .withCategory("config"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "hvacThermostat",
+                type: ["attributeReport", "readResponse"],
+                convert: async (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.valveAdaptStatus !== undefined) {
+                        result.valve_adapt_status = utils.getFromLookupByValue(data.valveAdaptStatus, valveAdaptStatusLookup);
+                        const automaticValveAdapt = meta.state.automatic_valve_adapt ?? false;
+                        if (automaticValveAdapt === true) {
+                            await triggerValveAdaptation(meta.state, msg.endpoint, false);
+                        }
+                    }
+                    if (data.automaticValveAdapt !== undefined) {
+                        result.automatic_valve_adapt = !!data.automaticValveAdapt;
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["valve_adapt_status", "automatic_valve_adapt", "valve_adapt_process"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (key === "valve_adapt_process") {
+                        await triggerValveAdaptation(meta.state, entity);
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    if (key === "valve_adapt_status") {
+                        await entity.read("hvacThermostat", ["valveAdaptStatus"]);
+                    }
+                    if (key === "automatic_valve_adapt") {
+                        await entity.read("hvacThermostat", ["automaticValveAdapt"]);
+                    }
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForReporting("hvacThermostat", "valveAdaptStatus", {
+                config: { min: "MIN", max: "MAX", change: null },
+                access: ea.STATE_GET,
+            }),
+            m.setupConfigureForReading("hvacThermostat", ["automaticValveAdapt"]),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+};
 //endregion
 //# sourceMappingURL=bosch.js.map