zigbee-herdsman-converters 25.34.0 → 25.35.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"));
@@ -49,10 +49,20 @@ const ea = exposes.access;
 const NS = "zhc:bosch";
 exports.manufacturerOptions = { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH };
 exports.boschGeneralExtend = {
+    /** 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) => {
@@ -75,7 +85,7 @@ exports.boschGeneralExtend = {
             isModernExtend: true,
         };
     },
-    customSeMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
+    customMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
         ID: zigbee_herdsman_1.Zcl.Clusters.seMetering.ID,
         attributes: {},
         commands: {
@@ -107,6 +117,12 @@ exports.boschGeneralExtend = {
             isModernExtend: true,
         };
     },
+    batteryWithPercentageAndLowStatus: (args) => m.battery({
+        percentage: true,
+        lowStatus: true,
+        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: null },
+        ...args,
+    }),
     autoOff: (args) => {
         const { endpoint } = args ?? {};
         const offOnLookup = {
@@ -1134,20 +1150,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",
@@ -1366,11 +1368,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"],
@@ -1660,7 +1657,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.
@@ -2016,5 +2013,528 @@ exports.boschSmartPlugExtend = {
         ...args,
     }),
 };
+const boschThermostatLookup = {
+    heaterType: {
+        underfloor_heating: 0x00,
+        central_heating: 0x03,
+        radiator: 0x02,
+    },
+};
+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 },
+        },
+        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 },
+            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: {},
+    }),
+    rmThermostat: () => m.thermostat({
+        setpoints: {
+            occupiedHeatingSetpoint: { min: 5, max: 30, step: 0.5 },
+            occupiedCoolingSetpoint: { min: 5, max: 30, step: 0.5 },
+        },
+        localTemperatureCalibration: { min: -5, max: 5, step: 0.1 },
+        systemMode: ["off", "heat", "cool"],
+        runningState: ["idle", "heat", "cool"],
+    }),
+    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,
+        reporting: { min: "MIN", max: "MAX", change: null },
+        access: "ALL",
+    }),
+    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 },
+        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",
+        lookup: boschThermostatLookup.heaterType,
+        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 },
+        entityCategory: "config",
+    }),
+    humidity: () => m.humidity(),
+    operatingMode: (args) => m.enumLookup({
+        name: "operating_mode",
+        cluster: "hvacThermostat",
+        attribute: "operatingMode",
+        description: "Bosch-specific operating mode",
+        lookup: { schedule: 0x00, manual: 0x01, pause: 0x05 },
+        reporting: { min: "MIN", max: "MAX", change: null },
+        ...args,
+    }),
+    windowOpenMode: () => 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: { min: "MIN", max: "MAX", change: null, attribute: "windowOpenMode" },
+    }),
+    childLock: () => m.binary({
+        name: "child_lock",
+        cluster: "hvacUserInterfaceCfg",
+        attribute: "keypadLockout",
+        description: "Enables/disables physical input on the device",
+        valueOn: ["LOCK", 0x01],
+        valueOff: ["UNLOCK", 0x00],
+        reporting: { min: "MIN", max: "MAX", change: null, attribute: "keypadLockout" },
+    }),
+    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,
+        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",
+        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 },
+        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 },
+        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,
+    }),
+    setpointChangeSource: () => 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",
+    }),
+    rmBattery: () => m.battery({
+        percentage: true,
+        percentageReporting: false,
+        voltage: true,
+        voltageReporting: true,
+        voltageToPercentage: { min: 4400, max: 6400 },
+        lowStatus: true,
+        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: null },
+    }),
+    raThermostat: () => {
+        const thermostat = m.thermostat({
+            localTemperature: {
+                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).",
+            },
+            setpoints: {
+                occupiedHeatingSetpoint: { min: 5, max: 30, step: 0.5 },
+            },
+            localTemperatureCalibration: { min: -5, max: 5, step: 0.1 },
+            systemMode: ["heat"],
+        });
+        const exposes = thermostat.exposes;
+        const fromZigbee = thermostat.fromZigbee;
+        const toZigbee = thermostat.toZigbee;
+        const configure = thermostat.configure;
+        const 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"];
+                }
+            },
+        };
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            meta,
+            isModernExtend: true,
+        };
+    },
+    customRunningState: () => {
+        const runningStates = ["idle", "heat"];
+        const exposes = [e.enum("running_state", ea.STATE_GET, runningStates).withDescription("The current running state")];
+        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 ? runningStates[1] : runningStates[0];
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["running_state"],
+                convertGet: async (entity, key, meta) => {
+                    await entity.read("hvacThermostat", ["heatingDemand"]);
+                },
+            },
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            isModernExtend: true,
+        };
+    },
+    boostHeating: () => {
+        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: { min: "MIN", max: "MAX", change: null },
+            }),
+            m.setupConfigureForReading("hvacThermostat", ["boostHeating"]),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    errorState: () => {
+        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: { min: "MIN", max: "MAX", change: null },
+            }),
+            m.setupConfigureForReading("hvacThermostat", ["errorState"]),
+        ];
+        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 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
+                .enum("valve_adapt_process", ea.SET, ["adapt"])
+                .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 = {};
+                    const data = msg.data;
+                    if (data.valveAdaptStatus !== undefined) {
+                        result.valve_adapt_status = utils.getFromLookupByValue(data.valveAdaptStatus, valveAdaptStatusLookup);
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["valve_adapt_status", "valve_adapt_process"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (key === "valve_adapt_process") {
+                        let adaptStatus;
+                        try {
+                            adaptStatus = utils.getFromLookup(meta.state.valve_adapt_status, valveAdaptStatusLookup);
+                        }
+                        catch {
+                            adaptStatus = valveAdaptStatusLookup.none;
+                        }
+                        switch (adaptStatus) {
+                            case valveAdaptStatusLookup.ready_to_calibrate:
+                            case valveAdaptStatusLookup.error:
+                                await entity.command("hvacThermostat", "calibrateValve", {}, exports.manufacturerOptions);
+                                break;
+                            default:
+                                throw new Error("Valve adaptation process not possible right now!");
+                        }
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    if (key === "valve_adapt_status") {
+                        await entity.read("hvacThermostat", ["valveAdaptStatus"]);
+                    }
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForReporting("hvacThermostat", "valveAdaptStatus", {
+                config: { min: "MIN", max: "MAX", change: null },
+            }),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    /** The Bosch thermostats ask the coordinator on several occasions for
+     * information about daylight saving time. As we don't support the setup
+     * of schedules, we just answer with 0x00 so that the device stops asking.
+     *
+     * Since Bosch devices don't seem to like it when we offer incomplete
+     * answers, we have to use a customReadResponse here and duplicate
+     * some code from zigbee-herdsman. */
+    handleDaylightSavingTimeReadRequest: () => {
+        const onEvent = [
+            (event) => {
+                if (event.type !== "start") {
+                    return;
+                }
+                event.data.device.customReadResponse = (frame, endpoint) => {
+                    const isTimeClusterRequest = frame.isCluster("genTime");
+                    if (!isTimeClusterRequest) {
+                        return false;
+                    }
+                    const daylightSavingTimeRequested = frame.payload.find((i) => i.attrId === zigbee_herdsman_1.Zcl.Clusters.genTime.attributes.dstStart.ID) &&
+                        frame.payload.find((i) => i.attrId === zigbee_herdsman_1.Zcl.Clusters.genTime.attributes.dstEnd.ID) &&
+                        frame.payload.find((i) => i.attrId === zigbee_herdsman_1.Zcl.Clusters.genTime.attributes.dstShift.ID);
+                    if (!daylightSavingTimeRequested) {
+                        return false;
+                    }
+                    const payload = {
+                        dstStart: 0x00,
+                        dstEnd: 0x00,
+                        dstShift: 0x00,
+                    };
+                    const OneJanuary2000 = new Date("January 01, 2000 00:00:00 UTC+00:00").getTime();
+                    const time = Math.round((Date.now() - OneJanuary2000) / 1000);
+                    const timeRequested = frame.payload.find((i) => i.attrId === zigbee_herdsman_1.Zcl.Clusters.genTime.attributes.time.ID);
+                    if (timeRequested) {
+                        payload.time = time;
+                    }
+                    const timeZoneRequested = frame.payload.find((i) => i.attrId === zigbee_herdsman_1.Zcl.Clusters.genTime.attributes.timeZone.ID);
+                    if (timeZoneRequested) {
+                        payload.timeZone = new Date().getTimezoneOffset() * -1 * 60;
+                    }
+                    const localTimeRequested = frame.payload.find((i) => i.attrId === zigbee_herdsman_1.Zcl.Clusters.genTime.attributes.localTime.ID);
+                    if (localTimeRequested) {
+                        payload.localTime = time - new Date().getTimezoneOffset() * 60;
+                    }
+                    endpoint.readResponse(frame.cluster.name, frame.header.transactionSequenceNumber, payload).catch((e) => {
+                        logger_1.logger.warning(`Custom genTime response failed for '${event.data.device.ieeeAddr}': ${e}`, NS);
+                    });
+                    return true;
+                };
+            },
+        ];
+        return {
+            onEvent,
+            isModernExtend: true,
+        };
+    },
+};
 //endregion
 //# sourceMappingURL=bosch.js.map