zigbee-herdsman-converters 25.35.0 → 25.36.0

package/dist/devices/bosch.js

@@ -36,7 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.definitions = void 0;
 const zigbee_herdsman_1 = require("zigbee-herdsman");
 const fz = __importStar(require("../converters/fromZigbee"));
+const tz = __importStar(require("../converters/toZigbee"));
 const bosch_1 = require("../lib/bosch");
+const constants = __importStar(require("../lib/constants"));
 const constants_1 = require("../lib/constants");
 const exposes = __importStar(require("../lib/exposes"));
 const logger_1 = require("../lib/logger");
@@ -108,6 +110,258 @@ const boschBmctDzSettings = {
     hasDualSwitchInputs: false,
 };
 const boschExtend = {
+    hvacThermostatCluster: () => m.deviceAddCustomCluster("hvacThermostat", {
+        ID: zigbee_herdsman_1.Zcl.Clusters.hvacThermostat.ID,
+        attributes: {
+            operatingMode: {
+                ID: 0x4007,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+            heatingDemand: {
+                ID: 0x4020,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+            valveAdaptStatus: {
+                ID: 0x4022,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+            remoteTemperature: {
+                ID: 0x4040,
+                type: zigbee_herdsman_1.Zcl.DataType.INT16,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+            windowDetection: {
+                ID: 0x4042,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+            boostHeating: {
+                ID: 0x4043,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+        },
+        commands: {
+            calibrateValve: {
+                ID: 0x41,
+                parameters: [],
+            },
+        },
+        commandsResponse: {},
+    }),
+    hvacUserInterfaceCfgCluster: () => m.deviceAddCustomCluster("hvacUserInterfaceCfg", {
+        ID: zigbee_herdsman_1.Zcl.Clusters.hvacUserInterfaceCfg.ID,
+        attributes: {
+            displayOrientation: {
+                ID: 0x400b,
+                type: zigbee_herdsman_1.Zcl.DataType.UINT8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+            displayedTemperature: {
+                ID: 0x4039,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+            displayOntime: {
+                ID: 0x403a,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+            displayBrightness: {
+                ID: 0x403b,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
+            },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    operatingMode: () => m.enumLookup({
+        name: "operating_mode",
+        cluster: "hvacThermostat",
+        attribute: "operatingMode",
+        reporting: { min: "10_SECONDS", max: "MAX", change: null },
+        description: "Bosch-specific operating mode (overrides system mode)",
+        lookup: { schedule: 0x00, manual: 0x01, pause: 0x05 },
+        zigbeeCommandOptions: bosch_1.manufacturerOptions,
+    }),
+    windowDetection: () => m.binary({
+        name: "window_detection",
+        cluster: "hvacThermostat",
+        attribute: "windowDetection",
+        description: "Enable/disable window open (Lo.) mode",
+        valueOn: ["ON", 0x01],
+        valueOff: ["OFF", 0x00],
+        zigbeeCommandOptions: bosch_1.manufacturerOptions,
+    }),
+    boostHeating: () => m.binary({
+        name: "boost_heating",
+        cluster: "hvacThermostat",
+        attribute: "boostHeating",
+        reporting: { min: "10_SECONDS", max: "MAX", change: null, attribute: "boostHeating" },
+        description: "Activate boost heating (5 min. on TRV)",
+        valueOn: ["ON", 0x01],
+        valueOff: ["OFF", 0x00],
+        zigbeeCommandOptions: bosch_1.manufacturerOptions,
+    }),
+    childLock: () => m.binary({
+        name: "child_lock",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "keypadLockout",
+        description: "Enables/disables physical input on the device",
+        valueOn: ["LOCK", 0x01],
+        valueOff: ["UNLOCK", 0x00],
+    }),
+    displayOntime: () => m.numeric({
+        name: "display_ontime",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "displayOntime",
+        description: "Sets the display on-time",
+        valueMin: 5,
+        valueMax: 30,
+        unit: "s",
+        zigbeeCommandOptions: bosch_1.manufacturerOptions,
+    }),
+    displayBrightness: () => m.numeric({
+        name: "display_brightness",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "displayBrightness",
+        description: "Sets brightness of the display",
+        valueMin: 0,
+        valueMax: 10,
+        zigbeeCommandOptions: bosch_1.manufacturerOptions,
+    }),
+    valveAdaptProcess: () => {
+        const adaptationStatus = {
+            none: 0x00,
+            ready_to_calibrate: 0x01,
+            calibration_in_progress: 0x02,
+            error: 0x03,
+            success: 0x04,
+        };
+        const exposes = [
+            e
+                .binary("valve_adapt_process", ea.ALL, true, false)
+                .withLabel("Trigger adaptation process")
+                .withDescription('Trigger the valve adaptation process. Only possible when adaptation status is "ready_to_calibrate" or "error".')
+                .withCategory("config"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "hvacThermostat",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    if (msg.data.valveAdaptStatus !== undefined) {
+                        if (msg.data.valveAdaptStatus === adaptationStatus.calibration_in_progress) {
+                            result.valve_adapt_process = true;
+                        }
+                        else {
+                            result.valve_adapt_process = false;
+                        }
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["valve_adapt_process"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (value === true) {
+                        const adaptStatus = utils.getFromLookup(meta.state.valve_adapt_status, adaptationStatus);
+                        switch (adaptStatus) {
+                            case adaptationStatus.ready_to_calibrate:
+                            case adaptationStatus.error:
+                                await entity.command("hvacThermostat", "calibrateValve", {}, bosch_1.manufacturerOptions);
+                                break;
+                            default:
+                                throw new Error("Valve adaptation process not possible right now.");
+                        }
+                    }
+                    return { state: { valve_adapt_process: value } };
+                },
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("hvacThermostat", ["valveAdaptStatus"], bosch_1.manufacturerOptions);
+                },
+            },
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            isModernExtend: true,
+        };
+    },
+    heatingDemand: () => {
+        const fromZigbee = [
+            {
+                cluster: "hvacThermostat",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    if (msg.data.heatingDemand !== undefined) {
+                        const demand = msg.data.heatingDemand;
+                        result.pi_heating_demand = demand;
+                        result.running_state = demand > 0 ? "heat" : "idle";
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["pi_heating_demand"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (key === "pi_heating_demand") {
+                        let demand = utils.toNumber(value, key);
+                        demand = utils.numberWithinRange(demand, 0, 100);
+                        await entity.write("hvacThermostat", { heatingDemand: demand }, bosch_1.manufacturerOptions);
+                        return { state: { pi_heating_demand: demand } };
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("hvacThermostat", ["heatingDemand"], bosch_1.manufacturerOptions);
+                },
+            },
+            {
+                key: ["running_state"],
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("hvacThermostat", ["heatingDemand"], bosch_1.manufacturerOptions);
+                },
+            },
+        ];
+        return {
+            fromZigbee,
+            toZigbee,
+            isModernExtend: true,
+        };
+    },
+    ignoreDst: () => {
+        const fromZigbee = [
+            {
+                cluster: "genTime",
+                type: "read",
+                convert: async (model, msg, publish, options, meta) => {
+                    if ("dstStart" in msg.data && "dstEnd" in msg.data && "dstShift" in msg.data) {
+                        const response = {
+                            dstStart: { attribute: 0x0003, status: zigbee_herdsman_1.Zcl.Status.SUCCESS, value: 0x00 },
+                            dstEnd: { attribute: 0x0004, status: zigbee_herdsman_1.Zcl.Status.SUCCESS, value: 0x00 },
+                            dstShift: { attribute: 0x0005, status: zigbee_herdsman_1.Zcl.Status.SUCCESS, value: 0x00 },
+                        };
+                        await msg.endpoint.readResponse(msg.cluster, msg.meta.zclTransactionSequenceNumber, response);
+                    }
+                },
+            },
+        ];
+        return {
+            fromZigbee,
+            isModernExtend: true,
+        };
+    },
     smokeAlarm: () => {
         const smokeAlarm = {
             OFF: 0x0000,
@@ -592,6 +846,7 @@ exports.definitions = [
             bosch_1.boschBsirExtend.deviceState(),
             bosch_1.boschBsirExtend.alarmControl(),
             bosch_1.boschBsirExtend.iasZoneStatus(),
+            bosch_1.boschBsirExtend.battery(),
             bosch_1.boschBsirExtend.alarmMode(),
             bosch_1.boschBsirExtend.sirenVolume(),
             bosch_1.boschBsirExtend.sirenDuration(),
@@ -601,9 +856,6 @@ exports.definitions = [
             bosch_1.boschBsirExtend.primaryPowerSource(),
             bosch_1.boschBsirExtend.currentPowerSource(),
             bosch_1.boschBsirExtend.solarPanelVoltage(),
-            bosch_1.boschGeneralExtend.batteryWithPercentageAndLowStatus({
-                percentageReportingConfig: { min: "MIN", max: "MAX", change: 1 },
-            }),
         ],
         ota: true,
     },
@@ -754,81 +1006,279 @@ exports.definitions = [
         model: "BTH-RA",
         vendor: "Bosch",
         description: "Radiator thermostat II",
+        meta: {
+            overrideHaDiscoveryPayload: (payload) => {
+                // Override climate discovery
+                // https://github.com/Koenkk/zigbee2mqtt/pull/23075#issue-2355829475
+                if (payload.mode_command_topic?.endsWith("/system_mode")) {
+                    payload.mode_command_topic = payload.mode_command_topic.substring(0, payload.mode_command_topic.lastIndexOf("/system_mode"));
+                    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' }}`;
+                    payload.modes = ["off", "heat", "auto"];
+                }
+            },
+        },
+        exposes: [
+            e
+                .climate()
+                .withLocalTemperature(ea.STATE_GET, "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).")
+                .withLocalTemperatureCalibration(-5, 5, 0.1)
+                .withSetpoint("occupied_heating_setpoint", 5, 30, 0.5)
+                .withSystemMode(["heat"])
+                .withRunningState(["idle", "heat"], ea.STATE_GET),
+            e.pi_heating_demand().withAccess(ea.ALL),
+        ],
+        fromZigbee: [fz.thermostat],
+        toZigbee: [
+            tz.thermostat_system_mode,
+            tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_local_temperature_calibration,
+            tz.thermostat_local_temperature,
+            tz.thermostat_keypad_lockout,
+        ],
         extend: [
-            bosch_1.boschThermostatExtend.handleDaylightSavingTimeReadRequest(),
-            bosch_1.boschThermostatExtend.customThermostatCluster(),
-            bosch_1.boschThermostatExtend.customUserInterfaceCfgCluster(),
-            bosch_1.boschThermostatExtend.raThermostat(),
-            bosch_1.boschThermostatExtend.setpointChangeSource(),
-            bosch_1.boschThermostatExtend.customHeatingDemand(),
-            bosch_1.boschThermostatExtend.customRunningState(),
-            bosch_1.boschThermostatExtend.operatingMode({
-                description: "Bosch-specific operating mode (overrides system mode)",
+            boschExtend.hvacThermostatCluster(),
+            boschExtend.hvacUserInterfaceCfgCluster(),
+            m.battery({
+                percentage: true,
+                lowStatus: false,
+            }),
+            boschExtend.operatingMode(),
+            boschExtend.windowDetection(),
+            boschExtend.boostHeating(),
+            m.numeric({
+                name: "remote_temperature",
+                cluster: "hvacThermostat",
+                attribute: "remoteTemperature",
+                description: "Input for remote temperature sensor. Required at least every 30 min. to prevent fallback to internal sensor!",
+                valueMin: 0.0,
+                valueMax: 35.0,
+                valueStep: 0.01,
+                unit: "°C",
+                scale: 100,
+                zigbeeCommandOptions: bosch_1.manufacturerOptions,
+            }),
+            m.enumLookup({
+                name: "setpoint_change_source",
+                cluster: "hvacThermostat",
+                attribute: "setpointChangeSource",
+                reporting: { min: "10_SECONDS", max: "MAX", change: null },
+                description: "Source of the current setpoint temperature",
+                lookup: { manual: 0x00, schedule: 0x01, externally: 0x02 },
+                access: "STATE_GET",
+            }),
+            boschExtend.childLock(),
+            boschExtend.displayOntime(),
+            boschExtend.displayBrightness(),
+            m.enumLookup({
+                name: "display_orientation",
+                cluster: "hvacUserInterfaceCfg",
+                attribute: "displayOrientation",
+                description: "Sets orientation of the display",
+                lookup: { normal: 0x00, flipped: 0x01 },
+                zigbeeCommandOptions: bosch_1.manufacturerOptions,
+            }),
+            m.enumLookup({
+                name: "displayed_temperature",
+                cluster: "hvacUserInterfaceCfg",
+                attribute: "displayedTemperature",
+                description: "Temperature displayed on the TRV",
+                lookup: { target: 0x00, measured: 0x01 },
+                zigbeeCommandOptions: bosch_1.manufacturerOptions,
+            }),
+            m.enumLookup({
+                name: "valve_adapt_status",
+                cluster: "hvacThermostat",
+                attribute: "valveAdaptStatus",
+                reporting: { min: "10_SECONDS", max: "MAX", change: null },
+                description: "Specifies the current status of the valve adaptation",
+                lookup: {
+                    none: 0x00,
+                    ready_to_calibrate: 0x01,
+                    calibration_in_progress: 0x02,
+                    error: 0x03,
+                    success: 0x04,
+                },
+                zigbeeCommandOptions: bosch_1.manufacturerOptions,
+                access: "STATE_GET",
+            }),
+            boschExtend.valveAdaptProcess(),
+            boschExtend.heatingDemand(),
+            boschExtend.ignoreDst(),
+            m.bindCluster({
+                cluster: "genPollCtrl",
+                clusterType: "input",
             }),
-            bosch_1.boschThermostatExtend.windowOpenMode(),
-            bosch_1.boschThermostatExtend.boostHeating(),
-            bosch_1.boschThermostatExtend.remoteTemperature(),
-            bosch_1.boschThermostatExtend.childLock(),
-            bosch_1.boschThermostatExtend.displayBrightness(),
-            bosch_1.boschThermostatExtend.displaySwitchOnDuration(),
-            bosch_1.boschThermostatExtend.displayOrientation(),
-            bosch_1.boschThermostatExtend.displayedTemperature(),
-            bosch_1.boschThermostatExtend.valveAdaptation(),
-            bosch_1.boschThermostatExtend.errorState(),
-            bosch_1.boschGeneralExtend.batteryWithPercentageAndLowStatus(),
         ],
         ota: true,
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["hvacThermostat", "hvacUserInterfaceCfg"]);
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint, {
+                min: constants.repInterval.SECONDS_10,
+                max: constants.repInterval.HOUR,
+                change: 50,
+            });
+            await reporting.thermostatKeypadLockMode(endpoint);
+            await endpoint.configureReporting("hvacThermostat", [
+                {
+                    attribute: "heatingDemand",
+                    minimumReportInterval: constants.repInterval.SECONDS_10,
+                    maximumReportInterval: constants.repInterval.MAX,
+                    reportableChange: null,
+                },
+            ], bosch_1.manufacturerOptions);
+            await endpoint.read("genPowerCfg", ["batteryPercentageRemaining"]);
+            await endpoint.read("hvacThermostat", ["localTemperatureCalibration", "setpointChangeSource"]);
+            await endpoint.read("hvacThermostat", ["operatingMode", "heatingDemand", "valveAdaptStatus", "remoteTemperature", "windowDetection", "boostHeating"], bosch_1.manufacturerOptions);
+            await endpoint.read("hvacUserInterfaceCfg", ["keypadLockout"]);
+            await endpoint.read("hvacUserInterfaceCfg", ["displayOrientation", "displayedTemperature", "displayOntime", "displayBrightness"], bosch_1.manufacturerOptions);
+        },
     },
     {
         zigbeeModel: ["RBSH-RTH0-BAT-ZB-EU"],
         model: "BTH-RM",
         vendor: "Bosch",
-        description: "Room thermostat II",
+        description: "Room thermostat II (Battery model)",
+        exposes: [
+            e
+                .climate()
+                .withLocalTemperature()
+                .withSetpoint("occupied_heating_setpoint", 4.5, 30, 0.5)
+                .withSetpoint("occupied_cooling_setpoint", 4.5, 30, 0.5)
+                .withLocalTemperatureCalibration(-5, 5, 0.1)
+                .withSystemMode(["off", "heat", "cool"])
+                .withRunningState(["idle", "heat", "cool"]),
+        ],
+        fromZigbee: [fz.thermostat, fz.hvac_user_interface],
+        toZigbee: [
+            tz.thermostat_system_mode,
+            tz.thermostat_running_state,
+            tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_occupied_cooling_setpoint,
+            tz.thermostat_programming_operation_mode, // NOTE: Only 0x0 & 0x1 supported
+            tz.thermostat_local_temperature_calibration,
+            tz.thermostat_local_temperature,
+            tz.thermostat_temperature_setpoint_hold,
+            tz.thermostat_temperature_display_mode,
+        ],
         extend: [
-            bosch_1.boschGeneralExtend.handleZclVersionReadRequest(),
-            bosch_1.boschThermostatExtend.handleDaylightSavingTimeReadRequest(),
-            bosch_1.boschThermostatExtend.customThermostatCluster(),
-            bosch_1.boschThermostatExtend.customUserInterfaceCfgCluster(),
-            bosch_1.boschThermostatExtend.rmThermostat(),
-            bosch_1.boschThermostatExtend.humidity(),
-            bosch_1.boschThermostatExtend.cableSensorMode(),
-            bosch_1.boschThermostatExtend.cableSensorTemperature(),
-            bosch_1.boschThermostatExtend.operatingMode(),
-            bosch_1.boschThermostatExtend.windowOpenMode(),
-            bosch_1.boschThermostatExtend.boostHeating(),
-            bosch_1.boschThermostatExtend.childLock(),
-            bosch_1.boschThermostatExtend.displayBrightness(),
-            bosch_1.boschThermostatExtend.displaySwitchOnDuration(),
-            bosch_1.boschThermostatExtend.errorState(),
-            bosch_1.boschThermostatExtend.rmBattery(),
+            boschExtend.hvacThermostatCluster(),
+            boschExtend.hvacUserInterfaceCfgCluster(),
+            m.battery({
+                voltageToPercentage: { min: 4400, max: 6400 },
+                percentage: true,
+                voltage: true,
+                lowStatus: false,
+                voltageReporting: true,
+                percentageReporting: false,
+            }),
+            m.humidity(),
+            boschExtend.operatingMode(),
+            boschExtend.windowDetection(),
+            boschExtend.boostHeating(),
+            boschExtend.childLock(),
+            boschExtend.displayOntime(),
+            boschExtend.displayBrightness(),
+            m.bindCluster({
+                cluster: "genPollCtrl",
+                clusterType: "input",
+            }),
         ],
         ota: true,
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["hvacThermostat", "hvacUserInterfaceCfg"]);
+            await reporting.thermostatSystemMode(endpoint);
+            await reporting.thermostatRunningState(endpoint);
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint, {
+                min: constants.repInterval.SECONDS_10,
+                max: constants.repInterval.HOUR,
+                change: 50,
+            });
+            await reporting.thermostatOccupiedCoolingSetpoint(endpoint, {
+                min: constants.repInterval.SECONDS_10,
+                max: constants.repInterval.HOUR,
+                change: 50,
+            });
+            await reporting.thermostatKeypadLockMode(endpoint);
+            await endpoint.read("genPowerCfg", ["batteryVoltage"]);
+            await endpoint.read("hvacThermostat", ["localTemperatureCalibration"]);
+            await endpoint.read("hvacThermostat", ["operatingMode", "windowDetection", "boostHeating"], bosch_1.manufacturerOptions);
+            await endpoint.read("hvacUserInterfaceCfg", ["keypadLockout"]);
+            await endpoint.read("hvacUserInterfaceCfg", ["displayOntime", "displayBrightness"], bosch_1.manufacturerOptions);
+        },
     },
     {
         zigbeeModel: ["RBSH-RTH0-ZB-EU"],
         model: "BTH-RM230Z",
         vendor: "Bosch",
         description: "Room thermostat II 230V",
+        exposes: [
+            e
+                .climate()
+                .withLocalTemperature()
+                .withSetpoint("occupied_heating_setpoint", 4.5, 30, 0.5)
+                .withSetpoint("occupied_cooling_setpoint", 4.5, 30, 0.5)
+                .withLocalTemperatureCalibration(-5, 5, 0.1)
+                .withSystemMode(["off", "heat", "cool"])
+                .withRunningState(["idle", "heat", "cool"]),
+        ],
+        fromZigbee: [fz.thermostat, fz.hvac_user_interface],
+        toZigbee: [
+            tz.thermostat_system_mode,
+            tz.thermostat_running_state,
+            tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_occupied_cooling_setpoint,
+            tz.thermostat_programming_operation_mode, // NOTE: Only 0x0 & 0x1 supported
+            tz.thermostat_local_temperature_calibration,
+            tz.thermostat_local_temperature,
+            tz.thermostat_temperature_setpoint_hold,
+            tz.thermostat_temperature_display_mode,
+        ],
         extend: [
-            bosch_1.boschGeneralExtend.handleZclVersionReadRequest(),
-            bosch_1.boschThermostatExtend.handleDaylightSavingTimeReadRequest(),
-            bosch_1.boschThermostatExtend.customThermostatCluster(),
-            bosch_1.boschThermostatExtend.customUserInterfaceCfgCluster(),
-            bosch_1.boschThermostatExtend.rmThermostat(),
-            bosch_1.boschThermostatExtend.humidity(),
-            bosch_1.boschThermostatExtend.cableSensorMode(),
-            bosch_1.boschThermostatExtend.cableSensorTemperature(),
-            bosch_1.boschThermostatExtend.heaterType(),
-            bosch_1.boschThermostatExtend.valveType(),
-            bosch_1.boschThermostatExtend.operatingMode(),
-            bosch_1.boschThermostatExtend.windowOpenMode(),
-            bosch_1.boschThermostatExtend.boostHeating(),
-            bosch_1.boschThermostatExtend.childLock(),
-            bosch_1.boschThermostatExtend.displayBrightness(),
-            bosch_1.boschThermostatExtend.displaySwitchOnDuration(),
-            bosch_1.boschThermostatExtend.errorState(),
+            boschExtend.hvacThermostatCluster(),
+            boschExtend.hvacUserInterfaceCfgCluster(),
+            m.humidity(),
+            boschExtend.operatingMode(),
+            boschExtend.windowDetection(),
+            boschExtend.boostHeating(),
+            boschExtend.childLock(),
+            boschExtend.displayOntime(),
+            boschExtend.displayBrightness(),
         ],
         ota: true,
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["hvacThermostat", "hvacUserInterfaceCfg"]);
+            await reporting.thermostatSystemMode(endpoint);
+            await reporting.thermostatRunningState(endpoint);
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint, {
+                min: constants.repInterval.SECONDS_10,
+                max: constants.repInterval.HOUR,
+                change: 50,
+            });
+            await reporting.thermostatOccupiedCoolingSetpoint(endpoint, {
+                min: constants.repInterval.SECONDS_10,
+                max: constants.repInterval.HOUR,
+                change: 50,
+            });
+            await reporting.thermostatKeypadLockMode(endpoint);
+            await endpoint.read("hvacThermostat", ["localTemperatureCalibration"]);
+            await endpoint.read("hvacThermostat", ["operatingMode", "windowDetection", "boostHeating"], bosch_1.manufacturerOptions);
+            await endpoint.read("hvacUserInterfaceCfg", ["keypadLockout"]);
+            await endpoint.read("hvacUserInterfaceCfg", ["displayOntime", "displayBrightness"], bosch_1.manufacturerOptions);
+        },
     },
     {
         zigbeeModel: ["Champion"],
@@ -958,7 +1408,7 @@ exports.definitions = [
         vendor: "Bosch",
         description: "Smart plug compact (type F plug)",
         extend: [
-            bosch_1.boschGeneralExtend.customMeteringCluster(),
+            bosch_1.boschGeneralExtend.customSeMeteringCluster(),
             bosch_1.boschSmartPlugExtend.smartPlugCluster(),
             bosch_1.boschSmartPlugExtend.onOff(),
             bosch_1.boschGeneralExtend.autoOff(),
@@ -978,7 +1428,7 @@ exports.definitions = [
         description: "Smart plug compact [+M]",
         extend: [
             bosch_1.boschGeneralExtend.handleZclVersionReadRequest(),
-            bosch_1.boschGeneralExtend.customMeteringCluster(),
+            bosch_1.boschGeneralExtend.customSeMeteringCluster(),
             bosch_1.boschSmartPlugExtend.smartPlugCluster(),
             bosch_1.boschSmartPlugExtend.onOff(),
             bosch_1.boschGeneralExtend.autoOff(),
@@ -998,7 +1448,7 @@ exports.definitions = [
             bosch_1.boschDoorWindowContactExtend.reportContactState(),
             bosch_1.boschDoorWindowContactExtend.reportButtonActions(),
             bosch_1.boschDoorWindowContactExtend.breakFunctionality(),
-            bosch_1.boschGeneralExtend.batteryWithPercentageAndLowStatus(),
+            bosch_1.boschDoorWindowContactExtend.battery(),
         ],
         ota: true,
     },
@@ -1013,7 +1463,7 @@ exports.definitions = [
             bosch_1.boschDoorWindowContactExtend.reportButtonActions(),
             bosch_1.boschDoorWindowContactExtend.vibrationDetection(),
             bosch_1.boschDoorWindowContactExtend.breakFunctionality(),
-            bosch_1.boschGeneralExtend.batteryWithPercentageAndLowStatus(),
+            bosch_1.boschDoorWindowContactExtend.battery(),
         ],
     },
     {
@@ -1026,7 +1476,7 @@ exports.definitions = [
             bosch_1.boschDoorWindowContactExtend.reportContactState(),
             bosch_1.boschDoorWindowContactExtend.reportButtonActions({ doublePressSupported: true }),
             bosch_1.boschDoorWindowContactExtend.breakFunctionality(),
-            bosch_1.boschGeneralExtend.batteryWithPercentageAndLowStatus(),
+            bosch_1.boschDoorWindowContactExtend.battery(),
         ],
     },
     {
@@ -1198,7 +1648,7 @@ exports.definitions = [
             }),
             bosch_1.boschGeneralExtend.handleZclVersionReadRequest(),
             bosch_1.boschBmctExtend.slzExtends(),
-            bosch_1.boschGeneralExtend.customMeteringCluster(),
+            bosch_1.boschGeneralExtend.customSeMeteringCluster(),
             bosch_1.boschGeneralExtend.resetEnergyMeters(),
         ],
         ota: true,