zigbee-herdsman-converters 25.45.0 → 25.46.0

package/dist/devices/bosch.js

@@ -36,9 +36,7 @@ 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");
@@ -110,258 +108,6 @@ 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,
@@ -846,7 +592,6 @@ 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(),
@@ -856,6 +601,9 @@ 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,
     },
@@ -1006,279 +754,81 @@ 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: [
-            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.customThermostatCluster(),
+            bosch_1.boschThermostatExtend.customUserInterfaceCfgCluster(),
+            bosch_1.boschThermostatExtend.raThermostat(),
+            bosch_1.boschThermostatExtend.setpointChangeSource({ enableReporting: true }),
+            bosch_1.boschThermostatExtend.operatingMode({ enableReporting: true }),
+            bosch_1.boschThermostatExtend.windowOpenMode({ enableReporting: true }),
+            bosch_1.boschThermostatExtend.boostHeating({ enableReporting: true }),
+            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({ enableReporting: true }),
+            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 (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,
-        ],
+        description: "Room thermostat II",
         extend: [
-            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",
-            }),
+            bosch_1.boschGeneralExtend.handleZclVersionReadRequest(),
+            bosch_1.boschThermostatExtend.customThermostatCluster(),
+            bosch_1.boschThermostatExtend.customUserInterfaceCfgCluster(),
+            bosch_1.boschThermostatExtend.customSystemMode(),
+            bosch_1.boschThermostatExtend.operatingMode(),
+            bosch_1.boschThermostatExtend.rmThermostat(),
+            bosch_1.boschThermostatExtend.setpointChangeSource(),
+            bosch_1.boschThermostatExtend.humidity(),
+            bosch_1.boschThermostatExtend.cableSensorMode(),
+            bosch_1.boschThermostatExtend.cableSensorTemperature(),
+            bosch_1.boschThermostatExtend.windowOpenMode(),
+            bosch_1.boschThermostatExtend.boostHeating(),
+            bosch_1.boschThermostatExtend.childLock(),
+            bosch_1.boschThermostatExtend.displayBrightness(),
+            bosch_1.boschThermostatExtend.displaySwitchOnDuration(),
+            bosch_1.boschThermostatExtend.activityLedState(),
+            bosch_1.boschThermostatExtend.errorState(),
+            bosch_1.boschThermostatExtend.rmBattery(),
         ],
         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: [
-            boschExtend.hvacThermostatCluster(),
-            boschExtend.hvacUserInterfaceCfgCluster(),
-            m.humidity(),
-            boschExtend.operatingMode(),
-            boschExtend.windowDetection(),
-            boschExtend.boostHeating(),
-            boschExtend.childLock(),
-            boschExtend.displayOntime(),
-            boschExtend.displayBrightness(),
+            bosch_1.boschGeneralExtend.handleZclVersionReadRequest(),
+            bosch_1.boschThermostatExtend.customThermostatCluster(),
+            bosch_1.boschThermostatExtend.customUserInterfaceCfgCluster(),
+            bosch_1.boschThermostatExtend.relayState(),
+            bosch_1.boschThermostatExtend.customSystemMode(),
+            bosch_1.boschThermostatExtend.operatingMode(),
+            bosch_1.boschThermostatExtend.rmThermostat(),
+            bosch_1.boschThermostatExtend.setpointChangeSource(),
+            bosch_1.boschThermostatExtend.humidity(),
+            bosch_1.boschThermostatExtend.heaterType(),
+            bosch_1.boschThermostatExtend.valveType(),
+            bosch_1.boschThermostatExtend.cableSensorMode(),
+            bosch_1.boschThermostatExtend.cableSensorTemperature(),
+            bosch_1.boschThermostatExtend.windowOpenMode(),
+            bosch_1.boschThermostatExtend.boostHeating(),
+            bosch_1.boschThermostatExtend.childLock(),
+            bosch_1.boschThermostatExtend.displayBrightness(),
+            bosch_1.boschThermostatExtend.displaySwitchOnDuration(),
+            bosch_1.boschThermostatExtend.activityLedState(),
+            bosch_1.boschThermostatExtend.errorState(),
         ],
         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"],
@@ -1408,7 +958,7 @@ exports.definitions = [
         vendor: "Bosch",
         description: "Smart plug compact (type F plug)",
         extend: [
-            bosch_1.boschGeneralExtend.customSeMeteringCluster(),
+            bosch_1.boschGeneralExtend.customMeteringCluster(),
             bosch_1.boschSmartPlugExtend.smartPlugCluster(),
             bosch_1.boschGeneralExtend.handleRenamedCustomCluster("boschSpecific", "boschEnergyDevice"),
             bosch_1.boschSmartPlugExtend.onOff(),
@@ -1429,7 +979,7 @@ exports.definitions = [
         description: "Smart plug compact [+M]",
         extend: [
             bosch_1.boschGeneralExtend.handleZclVersionReadRequest(),
-            bosch_1.boschGeneralExtend.customSeMeteringCluster(),
+            bosch_1.boschGeneralExtend.customMeteringCluster(),
             bosch_1.boschSmartPlugExtend.smartPlugCluster(),
             bosch_1.boschSmartPlugExtend.onOff(),
             bosch_1.boschGeneralExtend.autoOff(),
@@ -1450,7 +1000,7 @@ exports.definitions = [
             bosch_1.boschDoorWindowContactExtend.reportContactState(),
             bosch_1.boschDoorWindowContactExtend.reportButtonActions(),
             bosch_1.boschDoorWindowContactExtend.breakFunctionality(),
-            bosch_1.boschDoorWindowContactExtend.battery(),
+            bosch_1.boschGeneralExtend.batteryWithPercentageAndLowStatus(),
         ],
         ota: true,
     },
@@ -1466,7 +1016,7 @@ exports.definitions = [
             bosch_1.boschDoorWindowContactExtend.reportButtonActions(),
             bosch_1.boschDoorWindowContactExtend.vibrationDetection(),
             bosch_1.boschDoorWindowContactExtend.breakFunctionality(),
-            bosch_1.boschDoorWindowContactExtend.battery(),
+            bosch_1.boschGeneralExtend.batteryWithPercentageAndLowStatus(),
         ],
     },
     {
@@ -1480,7 +1030,7 @@ exports.definitions = [
             bosch_1.boschDoorWindowContactExtend.reportContactState(),
             bosch_1.boschDoorWindowContactExtend.reportButtonActions({ doublePressSupported: true }),
             bosch_1.boschDoorWindowContactExtend.breakFunctionality(),
-            bosch_1.boschDoorWindowContactExtend.battery(),
+            bosch_1.boschGeneralExtend.batteryWithPercentageAndLowStatus(),
         ],
     },
     {
@@ -1655,7 +1205,7 @@ exports.definitions = [
             bosch_1.boschGeneralExtend.handleRenamedCustomCluster("boschSpecific", "boschEnergyDevice"),
             bosch_1.boschGeneralExtend.handleZclVersionReadRequest(),
             bosch_1.boschBmctExtend.slzExtends(),
-            bosch_1.boschGeneralExtend.customSeMeteringCluster(),
+            bosch_1.boschGeneralExtend.customMeteringCluster(),
             bosch_1.boschGeneralExtend.resetEnergyMeters(),
         ],
         ota: true,