zigbee-herdsman-converters 25.9.0 → 25.10.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [25.10.0](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v25.9.0...v25.10.0) (2025-08-27)
+
+
+### Features
+
+* **add:** 929003808801 ([#9853](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9853)) ([e1e7f12](https://github.com/Koenkk/zigbee-herdsman-converters/commit/e1e7f12bf5210a9a363ee46451908f6c0f5207b7))
+* **add:** 929004297402 https://github.com/Koenkk/zigbee2mqtt/issues/28397 ([d238f93](https://github.com/Koenkk/zigbee-herdsman-converters/commit/d238f93bb8934fc51fe43a895d0b6adc09c1423c))
+* **add:** AirQ_Monitor_S01 ([#9841](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9841)) ([ff8b222](https://github.com/Koenkk/zigbee-herdsman-converters/commit/ff8b222636a76ee0ce98e1cc11bbcfeb601934d9))
+* **add:** FUT068ZR ([#9859](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9859)) ([56105e0](https://github.com/Koenkk/zigbee-herdsman-converters/commit/56105e0016f4e9e695998c91ba2161f8c2cbbf73))
+* Zemismart TB26-3: support more features ([#9849](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9849)) ([067a499](https://github.com/Koenkk/zigbee-herdsman-converters/commit/067a499849b2630fea779cbfa4584ccb55816a70))
+
+
+### Bug Fixes
+
+* Bosch `BMCT-SLZ`: various enhancements and fixes ([#9852](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9852)) ([2902e7c](https://github.com/Koenkk/zigbee-herdsman-converters/commit/2902e7ca4d9f422f35375501652e3ea79e854d74))
+* Correct vendor from GiEX to GIEX ([#9848](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9848)) ([d214855](https://github.com/Koenkk/zigbee-herdsman-converters/commit/d21485546be6642d3a929c11f0b49bd17473bcb3))
+* Create custom modernExtend classes to use with Inovelli devices ([#9835](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9835)) ([e3e76ad](https://github.com/Koenkk/zigbee-herdsman-converters/commit/e3e76ad2b628a4841b248ad163484c8dd8455354))
+* **detect:** Detect `929003811201` as Philips 5633030P6 ([#9851](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9851)) ([ba349f0](https://github.com/Koenkk/zigbee-herdsman-converters/commit/ba349f0728767df85cbee1884a51f6dc6f250eb5))
+* Tuya `_TZ3000_okaz9tjs`: fix configure failing https://github.com/Koenkk/zigbee-herdsman-converters/issues/9786 ([1d9f8bb](https://github.com/Koenkk/zigbee-herdsman-converters/commit/1d9f8bbc1309d91e71368b9ff71db19b50246bda))
+* Various code fixes ([#9854](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9854)) ([7ba943e](https://github.com/Koenkk/zigbee-herdsman-converters/commit/7ba943e6abaa9978c00d048dfeac80d3721fd4ae))
+
 ## [25.9.0](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v25.8.0...v25.9.0) (2025-08-25)
 
 

package/dist/devices/bosch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bosch.d.ts","sourceRoot":"","sources":["../../src/devices/bosch.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAC,oBAAoB,EAAyC,MAAM,cAAc,CAAC;AAwuC/F,eAAO,MAAM,WAAW,EAAE,oBAAoB,EA68B7C,CAAC"}
+{"version":3,"file":"bosch.d.ts","sourceRoot":"","sources":["../../src/devices/bosch.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,oBAAoB,EAAyC,MAAM,cAAc,CAAC;AAk3C/F,eAAO,MAAM,WAAW,EAAE,oBAAoB,EAwoC7C,CAAC"}

package/dist/devices/bosch.js

@@ -38,10 +38,12 @@ const zigbee_herdsman_1 = require("zigbee-herdsman");
 const fz = __importStar(require("../converters/fromZigbee"));
 const tz = __importStar(require("../converters/toZigbee"));
 const constants = __importStar(require("../lib/constants"));
+const constants_1 = require("../lib/constants");
 const exposes = __importStar(require("../lib/exposes"));
 const logger_1 = require("../lib/logger");
 const m = __importStar(require("../lib/modernExtend"));
 const reporting = __importStar(require("../lib/reporting"));
+const reporting_1 = require("../lib/reporting");
 const globalStore = __importStar(require("../lib/store"));
 const utils = __importStar(require("../lib/utils"));
 const e = exposes.presets;
@@ -352,6 +354,38 @@ const boschExtend = {
             isModernExtend: true,
         };
     },
+    seMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
+        ID: zigbee_herdsman_1.Zcl.Clusters.seMetering.ID,
+        attributes: {},
+        commands: {
+            resetEnergyReading: {
+                ID: 0x80,
+                parameters: [],
+            },
+        },
+        commandsResponse: {},
+    }),
+    resetEnergyReading: () => {
+        const exposes = [
+            e
+                .enum("reset_energy_reading", ea.SET, ["reset"])
+                .withDescription("Triggers the reset of the energy reading to 0 kWh.")
+                .withCategory("config"),
+        ];
+        const toZigbee = [
+            {
+                key: ["reset_energy_reading"],
+                convertSet: async (entity, key, value, meta) => {
+                    await entity.command("seMetering", "resetEnergyReading", {}, manufacturerOptions);
+                },
+            },
+        ];
+        return {
+            exposes,
+            toZigbee,
+            isModernExtend: true,
+        };
+    },
     doorWindowContact: (hasVibrationSensor) => {
         const exposes = [
             e.binary("contact", ea.STATE, false, true).withDescription("Indicates whether the device is opened or closed"),
@@ -789,21 +823,59 @@ const boschExtend = {
             stopped: 0x00,
             opening: 0x01,
             closing: 0x02,
+            unknownOne: 0x03,
+            unknownTwo: 0x04,
         };
         const stateSwitchType = {
             button: 0x01,
             button_key_change: 0x02,
             rocker_switch: 0x03,
             rocker_switch_key_change: 0x04,
+            none: 0x00,
+        };
+        const stateSwitchMode = {
+            coupled: 0x00,
+            decoupled: 0x01,
+            only_short_press_decoupled: 0x02,
+            only_long_press_decoupled: 0x03,
         };
         const stateOffOn = {
             OFF: 0x00,
             ON: 0x01,
         };
         const fromZigbee = [
-            fz.on_off,
+            fz.on_off_force_multiendpoint,
             fz.power_on_behavior,
             fz.cover_position_tilt,
+            {
+                cluster: "boschSpecific",
+                type: ["raw"],
+                convert: (model, msg, publish, options, meta) => {
+                    const command = msg.data[4];
+                    if (command !== 0x03 && command !== 0x04) {
+                        return;
+                    }
+                    let state;
+                    const status = msg.data[5];
+                    const duration = msg.data[6] / 10;
+                    switch (status) {
+                        case 0:
+                            state = "press_released";
+                            break;
+                        case 1:
+                            state = duration !== 0 ? "hold" : "hold_released";
+                            break;
+                        case 2:
+                            state = "closed";
+                            break;
+                        case 3:
+                            state = "opened";
+                            break;
+                    }
+                    const triggeredSide = command === 0x03 ? "left" : "right";
+                    return { action: `${state}_${triggeredSide}`, action_duration: duration };
+                },
+            },
             {
                 cluster: "boschSpecific",
                 type: ["attributeReport", "readResponse"],
@@ -821,6 +893,10 @@ const boschExtend = {
                     if (data.switchType !== undefined) {
                         result.switch_type = Object.keys(stateSwitchType).find((key) => stateSwitchType[key] === msg.data.switchType);
                     }
+                    if (data.switchMode !== undefined) {
+                        const property = utils.postfixWithEndpointName("switch_mode", msg, model, meta);
+                        result[property] = Object.keys(stateSwitchMode).find((key) => stateSwitchMode[key] === msg.data.switchMode);
+                    }
                     if (data.calibrationOpeningTime !== undefined) {
                         result.calibration_opening_time = msg.data.calibrationOpeningTime / 10;
                     }
@@ -840,6 +916,14 @@ const boschExtend = {
                     if (data.motorState !== undefined) {
                         result.motor_state = Object.keys(stateMotor).find((key) => stateMotor[key] === msg.data.motorState);
                     }
+                    if (data.autoOffEnabled !== undefined) {
+                        const property = utils.postfixWithEndpointName("auto_off_enabled", msg, model, meta);
+                        result[property] = msg.data.autoOffEnabled === 1 ? "ON" : "OFF";
+                    }
+                    if (data.autoOffTime !== undefined) {
+                        const property = utils.postfixWithEndpointName("auto_off_time", msg, model, meta);
+                        result[property] = msg.data.autoOffTime / 60;
+                    }
                     return result;
                 },
             },
@@ -848,7 +932,17 @@ const boschExtend = {
             tz.power_on_behavior,
             tz.cover_position_tilt,
             {
-                key: ["device_mode", "switch_type", "child_lock", "state", "on_time", "off_wait_time"],
+                key: [
+                    "device_mode",
+                    "switch_type",
+                    "switch_mode",
+                    "child_lock",
+                    "state",
+                    "on_time",
+                    "off_wait_time",
+                    "auto_off_enabled",
+                    "auto_off_time",
+                ],
                 convertSet: async (entity, key, value, meta) => {
                     if (key === "state") {
                         if ("ID" in entity && entity.ID === 1) {
@@ -874,11 +968,25 @@ const boschExtend = {
                         await entity.write("boschSpecific", { switchType: index });
                         return { state: { switch_type: value } };
                     }
+                    if (key === "switch_mode") {
+                        const index = utils.getFromLookup(value, stateSwitchMode);
+                        await entity.write("boschSpecific", { switchMode: index });
+                        return { state: { switch_mode: value } };
+                    }
                     if (key === "child_lock") {
                         const index = utils.getFromLookup(value, stateOffOn);
                         await entity.write("boschSpecific", { childLock: index });
                         return { state: { child_lock: value } };
                     }
+                    if (key === "auto_off_enabled") {
+                        const index = utils.getFromLookup(value, stateOffOn);
+                        await entity.write("boschSpecific", { autoOffEnabled: index });
+                        return { state: { auto_off_enabled: value } };
+                    }
+                    if (key === "auto_off_time" && typeof value === "number") {
+                        await entity.write("boschSpecific", { autoOffTime: value * 60 });
+                        return { state: { auto_off_time: value } };
+                    }
                 },
                 convertGet: async (entity, key, meta) => {
                     switch (key) {
@@ -895,9 +1003,18 @@ const boschExtend = {
                         case "switch_type":
                             await entity.read("boschSpecific", ["switchType"]);
                             break;
+                        case "switch_mode":
+                            await entity.read("boschSpecific", ["switchMode"]);
+                            break;
                         case "child_lock":
                             await entity.read("boschSpecific", ["childLock"]);
                             break;
+                        case "auto_off_enabled":
+                            await entity.read("boschSpecific", ["autoOffEnabled"]);
+                            break;
+                        case "auto_off_time":
+                            await entity.read("boschSpecific", ["autoOffTime"]);
+                            break;
                         default:
                             throw new Error(`Unhandled key boschExtend.bmct.toZigbee.convertGet ${key}`);
                     }
@@ -1834,48 +1951,130 @@ exports.definitions = [
         description: "Light/shutter control unit II",
         extend: [
             m.deviceEndpoints({ endpoints: { left: 2, right: 3 } }),
-            m.electricityMeter({ voltage: false, current: false }),
+            m.electricityMeter({
+                voltage: false,
+                current: false,
+                power: { change: 1 },
+                energy: { change: 1 },
+            }),
             m.deviceAddCustomCluster("boschSpecific", {
                 ID: 0xfca0,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH,
                 attributes: {
                     deviceMode: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.ENUM8 },
                     switchType: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.ENUM8 },
+                    switchMode: { ID: 0x0031, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
                     calibrationOpeningTime: { ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
                     calibrationClosingTime: { ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+                    // 0x0005 isn't used at all when using the Bosch SHC as of 30-06-2025.
+                    // As I don't have any shutters, I can't run all calibration steps
+                    // successfully. So, keep any comments regarding these
+                    // attributes with caution.
                     calibrationButtonHoldTime: { ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    autoOffEnabled: { ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    autoOffTime: { ID: 0x0007, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
                     childLock: { ID: 0x0008, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    // 0x000f is only being set when using the automatic calibration.
+                    // It's being set to 0 then before sending the calibration
+                    // command. Additionally, when changing
+                    // the calibrationOpeningTime or calibrationClosingTime in the
+                    // Bosch app, it's also being set to 0.
+                    // I couldn't find any way to set 0x000f manually in the Bosch app.
                     calibrationMotorStartDelay: { ID: 0x000f, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    calibrationMotorReverseDirection: { ID: 0x0032, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
                     motorState: { ID: 0x0013, type: zigbee_herdsman_1.Zcl.DataType.ENUM8 },
+                    // unknownAttributeOne is always being configured as reporting
+                    // attribute on endpoint 1 when using the Bosch SHC.
+                    // Can't tell what this attribute does (always received
+                    // 0x00 as answer on manual lookup).
+                    unknownAttributeOne: { ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.BITMAP8 },
+                    // Attribute is being set to 255 when deactivating the automatic
+                    // detection of the motor end position by the Bosch SHC. After
+                    // activating the automatic end position detection it's being set
+                    // to 0 by the Bosch SHC. Apart from that, there's no way to manually
+                    // change the value.
+                    calibrationMotorEndPosition: { ID: 0x0021, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    // 0x0033 is used when setting the motor start delay manually
+                    // using the Bosch SHC as of 30-06-2025.
+                    // If the user wants to automatically detect the delay during
+                    // calibration, it's being set to 0 over the Bosch app.
+                    calibrationNewMotorStartDelay: { ID: 0x0033, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+                    // 0x0010 and 0x0011 is being set simultaneously with the same value
+                    // when changing the delay for the rotation of the slats on venetian
+                    // blinds. Maybe one attribute for each direction?
+                    // It's also being configured as reporting attribute when using
+                    // venetian blinds.
+                    slatRotationDurationOne: { ID: 0x0010, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+                    slatRotationDurationTwo: { ID: 0x0011, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+                    // 0x002a is only being used when doing an automatic calibration
+                    // with the Bosch specific startAutomaticMotorCalibration command.
+                    // It's being set to true before starting the calibration process.
+                    // This happens regardless of the shutter type. I didn't capture
+                    // any packages where this attribute is being actively set to false.
+                    // Maybe this activates some "full calibration" flag which is being
+                    // set to false by the device itself afterward?
+                    unknownAttributeTwo: { ID: 0x002a, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                },
+                commands: {
+                    // Command being sent by the Bosch SHC when starting an
+                    // automatic shutter calibration.
+                    startAutomaticMotorCalibration: { ID: 0x00, parameters: [] },
                 },
-                commands: {},
                 commandsResponse: {},
             }),
             boschExtend.bmct(),
+            boschExtend.seMeteringCluster(),
+            boschExtend.resetEnergyReading(),
         ],
         ota: true,
         configure: async (device, coordinatorEndpoint) => {
+            const lightConfiguration = async () => {
+                const endpoint1 = device.getEndpoint(1);
+                await reporting.bind(endpoint1, coordinatorEndpoint, ["genIdentify"]);
+                await endpoint1.read("boschSpecific", ["switchType"]);
+                const endpoint2 = device.getEndpoint(2);
+                await reporting.bind(endpoint2, coordinatorEndpoint, ["genIdentify", "genOnOff", "boschSpecific"]);
+                await reporting.onOff(endpoint2);
+                await endpoint2.read("genOnOff", ["onOff", "startUpOnOff"]);
+                await endpoint2.read("boschSpecific", [
+                    "switchMode",
+                    "childLock",
+                    "autoOffEnabled",
+                    "autoOffTime",
+                ]);
+                const endpoint3 = device.getEndpoint(3);
+                await reporting.bind(endpoint3, coordinatorEndpoint, ["genIdentify", "genOnOff", "boschSpecific"]);
+                await reporting.onOff(endpoint3);
+                await endpoint3.read("genOnOff", ["onOff", "startUpOnOff"]);
+                await endpoint3.read("boschSpecific", [
+                    "switchMode",
+                    "childLock",
+                    "autoOffEnabled",
+                    "autoOffTime",
+                ]);
+            };
+            const shutterConfiguration = async () => {
+                const endpoint1 = device.getEndpoint(1);
+                await reporting.bind(endpoint1, coordinatorEndpoint, ["genIdentify", "closuresWindowCovering", "boschSpecific"]);
+                await reporting.currentPositionLiftPercentage(endpoint1);
+                await endpoint1.read("closuresWindowCovering", ["currentPositionLiftPercentage"]);
+                const payloadMotorState = (0, reporting_1.payload)("motorState", 0, constants_1.repInterval.MAX, 0);
+                await endpoint1.configureReporting("boschSpecific", payloadMotorState);
+                await endpoint1.read("boschSpecific", [
+                    "switchType",
+                    "switchMode",
+                    "motorState",
+                    "calibrationOpeningTime",
+                    "calibrationClosingTime",
+                    "calibrationButtonHoldTime",
+                    "calibrationMotorStartDelay",
+                    "childLock",
+                ]);
+            };
             const endpoint1 = device.getEndpoint(1);
-            await reporting.bind(endpoint1, coordinatorEndpoint, ["genIdentify", "closuresWindowCovering", "boschSpecific"]);
-            await reporting.currentPositionLiftPercentage(endpoint1);
-            await endpoint1.read("boschSpecific", [
-                "deviceMode",
-                "switchType",
-                "motorState",
-                "childLock",
-                "calibrationOpeningTime",
-                "calibrationClosingTime",
-                "calibrationButtonHoldTime",
-                "calibrationMotorStartDelay",
-            ]);
-            const endpoint2 = device.getEndpoint(2);
-            await endpoint2.read("boschSpecific", ["childLock"]);
-            await reporting.bind(endpoint2, coordinatorEndpoint, ["genIdentify", "genOnOff"]);
-            await reporting.onOff(endpoint2);
-            const endpoint3 = device.getEndpoint(3);
-            await endpoint3.read("boschSpecific", ["childLock"]);
-            await reporting.bind(endpoint3, coordinatorEndpoint, ["genIdentify", "genOnOff"]);
-            await reporting.onOff(endpoint3);
+            await endpoint1.read("boschSpecific", ["deviceMode"]);
+            await lightConfiguration();
+            await shutterConfiguration();
         },
         exposes: (device, options) => {
             const stateDeviceMode = {
@@ -1893,15 +2092,67 @@ exports.definitions = [
                 button_key_change: 0x02,
                 rocker_switch: 0x03,
                 rocker_switch_key_change: 0x04,
+                none: 0x00,
+            };
+            const stateSwitchMode = {
+                coupled: 0x00,
+                decoupled: 0x01,
+                only_short_press_decoupled: 0x02,
+                only_long_press_decoupled: 0x03,
             };
             const commonExposes = [
                 e.enum("switch_type", ea.ALL, Object.keys(stateSwitchType)).withDescription("Module controlled by a rocker switch or a button"),
+                e.action([
+                    "press_released_left",
+                    "press_released_right",
+                    "hold_left",
+                    "hold_right",
+                    "hold_released_left",
+                    "hold_released_right",
+                    "opened_left",
+                    "opened_right",
+                    "closed_left",
+                    "closed_right",
+                ]),
+                e.action_duration(),
             ];
             const lightExposes = [
                 e.switch().withEndpoint("left"),
                 e.switch().withEndpoint("right"),
                 e.power_on_behavior().withEndpoint("left"),
                 e.power_on_behavior().withEndpoint("right"),
+                e
+                    .enum("switch_mode", ea.ALL, Object.keys(stateSwitchMode))
+                    .withEndpoint("left")
+                    .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that not all options may work depending on your switch type."),
+                e
+                    .enum("switch_mode", ea.ALL, Object.keys(stateSwitchMode))
+                    .withEndpoint("right")
+                    .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that not all options may work depending on your switch type."),
+                e
+                    .binary("auto_off_enabled", ea.ALL, "ON", "OFF")
+                    .withEndpoint("left")
+                    .withDescription("Enable/Disable the automatic turn-off feature"),
+                e
+                    .binary("auto_off_enabled", ea.ALL, "ON", "OFF")
+                    .withEndpoint("right")
+                    .withDescription("Enable/Disable the automatic turn-off feature"),
+                e
+                    .numeric("auto_off_time", ea.ALL)
+                    .withValueMin(0)
+                    .withValueMax(720)
+                    .withValueStep(1)
+                    .withUnit("min")
+                    .withDescription("Turn off the output after the specified amount of time. Only in action when the automatic turn-off is enabled.")
+                    .withEndpoint("left"),
+                e
+                    .numeric("auto_off_time", ea.ALL)
+                    .withValueMin(0)
+                    .withValueMax(720)
+                    .withValueStep(1)
+                    .withUnit("min")
+                    .withDescription("Turn off the output after the specified amount of time. Only in action when the automatic turn-off is enabled.")
+                    .withEndpoint("right"),
                 e.binary("child_lock", ea.ALL, "ON", "OFF").withEndpoint("left").withDescription("Enable/Disable child lock"),
                 e.binary("child_lock", ea.ALL, "ON", "OFF").withEndpoint("right").withDescription("Enable/Disable child lock"),
             ];
@@ -1909,6 +2160,9 @@ exports.definitions = [
                 e.cover_position(),
                 e.enum("motor_state", ea.STATE, Object.keys(stateMotor)).withDescription("Current shutter motor state"),
                 e.binary("child_lock", ea.ALL, "ON", "OFF").withDescription("Enable/Disable child lock"),
+                e
+                    .enum("switch_mode", ea.ALL, Object.keys(stateSwitchMode).filter((switchMode) => switchMode === "coupled" || switchMode === "only_long_press_decoupled"))
+                    .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that not all options may work depending on your switch type."),
                 e
                     .numeric("calibration_closing_time", ea.ALL)
                     .withUnit("s")
@@ -1950,6 +2204,34 @@ exports.definitions = [
             }
             return [e.enum("device_mode", ea.ALL, Object.keys(stateDeviceMode)).withDescription("Device mode")];
         },
+        onEvent: (event) => {
+            if (event.type !== "deviceInterview") {
+                return;
+            }
+            // During interview, the Bosch BMCT-SLZ is requesting
+            // the zclVersion attribute from the coordinator. As
+            // Z2M doesn't know the zclVersion of the device yet,
+            // the request is left unanswered. This makes the device
+            // believe it dropped out of network every 10 minutes which
+            // not only generates unnecessary network congestion, but
+            // makes the LED on the device blink during that sequence
+            // as well. To prevent that, we have to manually answer
+            // the zclVersion request at the earliest possible stage
+            // and mimic the answer from the Bosch SHC II.
+            event.data.device.customReadResponse = (frame, endpoint) => {
+                const isZclVersionRequest = frame.isCluster("genBasic") && frame.payload.find((i) => i.attrId === 0);
+                if (!isZclVersionRequest) {
+                    return false;
+                }
+                const payload = {
+                    zclVersion: 1,
+                };
+                endpoint.readResponse(frame.cluster.name, frame.header.transactionSequenceNumber, payload).catch((e) => {
+                    logger_1.logger.warning(`Custom zclVersion response failed for '${event.data.device.ieeeAddr}': ${e}`, NS);
+                });
+                return true;
+            };
+        },
     },
     {
         zigbeeModel: ["RBSH-US4BTN-ZB-EU"],