zigbee-herdsman-converters 25.35.0 → 25.36.0

package/dist/lib/bosch.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.boschThermostatExtend = exports.boschSmartPlugExtend = exports.boschBsenExtend = exports.boschDoorWindowContactExtend = exports.boschBsirExtend = exports.boschBmctExtend = exports.boschGeneralExtend = exports.manufacturerOptions = void 0;
+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,20 +49,10 @@ 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 !== "start") {
+                if (event.type !== "deviceAnnounce") {
                     return;
                 }
                 event.data.device.customReadResponse = (frame, endpoint) => {
@@ -85,7 +75,7 @@ exports.boschGeneralExtend = {
             isModernExtend: true,
         };
     },
-    customMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
+    customSeMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
         ID: zigbee_herdsman_1.Zcl.Clusters.seMetering.ID,
         attributes: {},
         commands: {
@@ -117,12 +107,6 @@ 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 = {
@@ -1150,6 +1134,20 @@ 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",
@@ -1368,6 +1366,11 @@ 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"],
@@ -1657,7 +1660,7 @@ exports.boschBsenExtend = {
         voltageReporting: true,
         voltageToPercentage: { min: 2500, max: 3000 },
         lowStatus: true,
-        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: null },
+        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: 0 },
     }),
     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.
@@ -2013,528 +2016,5 @@ 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