zigbee-herdsman-converters 25.44.0 → 25.46.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.boschBsenExtend = exports.boschDoorWindowContactExtend = exports.boschBsirExtend = exports.boschBmctExtend = 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"));
@@ -98,10 +98,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 +134,7 @@ exports.boschGeneralExtend = {
             isModernExtend: true,
         };
     },
-    customSeMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
+    customMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
         ID: zigbee_herdsman_1.Zcl.Clusters.seMetering.ID,
         attributes: {},
         commands: {
@@ -156,6 +166,13 @@ exports.boschGeneralExtend = {
             isModernExtend: true,
         };
     },
+    batteryWithPercentageAndLowStatus: (args) => m.battery({
+        percentage: true,
+        percentageReportingConfig: false,
+        lowStatus: true,
+        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: null },
+        ...args,
+    }),
     autoOff: (args) => {
         const { endpoint } = args ?? {};
         const offOnLookup = {
@@ -1183,20 +1200,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 +1418,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"],
@@ -1665,9 +1663,12 @@ exports.boschDoorWindowContactExtend = {
                 // Bosch Smart Home Controller II as of 19-09-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("boschDoorWindowContactCluster", {
-                    vibrationDetectionSensitivity: vibrationDetectionSensitivityLookup.medium,
-                });
+                if (device.meta.newDefaultSensitivityApplied === undefined) {
+                    await endpoint.write("boschDoorWindowContactCluster", {
+                        vibrationDetectionSensitivity: vibrationDetectionSensitivityLookup.medium,
+                    });
+                    device.meta.newDefaultSensitivityApplied = true;
+                }
                 // The write request is made when using the proprietary
                 // Bosch Smart Home Controller II as of 19-09-2025. I have
                 // no idea what it does, but we mimic it here in case it
@@ -1709,7 +1710,7 @@ 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 },
     }),
     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.
@@ -2065,5 +2066,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