zigbee-herdsman-converters 25.9.0 → 25.11.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [25.11.0](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v25.10.0...v25.11.0) (2025-08-28)
+
+
+### Features
+
+* **add:** AE 287 C ([#9864](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9864)) ([5f927fd](https://github.com/Koenkk/zigbee-herdsman-converters/commit/5f927fd292fbba0953c5a637002d7ffe952489bb))
+* **add:** Drivent ([#9874](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9874)) ([c8dcb6f](https://github.com/Koenkk/zigbee-herdsman-converters/commit/c8dcb6f2bedef654698bd2840beaaf79005d596d))
+* **add:** m5NanoC6 ([#9866](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9866)) ([95ca5db](https://github.com/Koenkk/zigbee-herdsman-converters/commit/95ca5db499581c2687ec830e1f98fa5a2ae3e055))
+* Bosch `BSP-FZ2` (Plug compact II): Support reset of energy meter and lower min value change on electricityMeter reporting ([#9865](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9865)) ([0615f2d](https://github.com/Koenkk/zigbee-herdsman-converters/commit/0615f2d6999ab011ef22b7ee9414ae1181b6df24))
+* Onokom: various improvements ([#9869](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9869)) ([15acfc4](https://github.com/Koenkk/zigbee-herdsman-converters/commit/15acfc4f8e148e5b09546541608e2c1822ee8ec4))
+
+
+### Bug Fixes
+
+* Create inovelliMMWave modern extend to relocate mmWave commands and support future expansion ([#9870](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9870)) ([a88b08c](https://github.com/Koenkk/zigbee-herdsman-converters/commit/a88b08ca0093d38d9bffeeecd9ad55b5cfbc793f))
+* **detect:** Detect `_TZ3000_fawk5xjv` and `_TZ3000_ok0ggpk7` as a Detect _TZ3000_fawk5xjv and _TZ3000_ok0ggpk7 as a TS0003_switch_3_gang_with_backlight ([#9861](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9861)) ([1b539d2](https://github.com/Koenkk/zigbee-herdsman-converters/commit/1b539d2a9309432fcaf34236feddc523e56027a0))
+* **detect:** Detect `_TZE200_jfw0a4aa` as ZG-102ZM and `_TZE200_hdih4foa` as ZG-204ZH ([#9872](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9872)) ([8437961](https://github.com/Koenkk/zigbee-herdsman-converters/commit/8437961b762ce769cd10fadd0dd2a731aac2a5ed))
+* **detect:** Detect `_TZE284_1lvln0x6` as iHsenso_TS0601_human_presence https://github.com/Koenkk/zigbee2mqtt/issues/28398 ([b60f84f](https://github.com/Koenkk/zigbee-herdsman-converters/commit/b60f84fd14036c12a380f6f04e2b91681c2d5ec0))
+* **detect:** Detect `lumi.light.agl002` as Aqara T2_E26 https://github.com/Koenkk/zigbee2mqtt/issues/26182 ([e221d02](https://github.com/Koenkk/zigbee-herdsman-converters/commit/e221d023ec8d188c4f25ba3b19bdd87c0154b3a0))
+* **ignore:** Bosch `BMCT-SLZ` (Light/shutter control unit II): Only expose attributes compatible with the selected switch type ([#9862](https://github.com/Koenkk/zigbee-herdsman-converters/issues/9862)) ([7eecc4e](https://github.com/Koenkk/zigbee-herdsman-converters/commit/7eecc4e751812a27ce65f38565199dcd63cac809))
+
+## [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,EAA6C,MAAM,cAAc,CAAC;AA44CnG,eAAO,MAAM,WAAW,EAAE,oBAAoB,EAmsC7C,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"],
@@ -819,7 +891,16 @@ const boschExtend = {
                         }
                     }
                     if (data.switchType !== undefined) {
-                        result.switch_type = Object.keys(stateSwitchType).find((key) => stateSwitchType[key] === msg.data.switchType);
+                        const switchType = msg.data.switchType;
+                        result.switch_type = Object.keys(stateSwitchType).find((key) => stateSwitchType[key] === switchType);
+                        if (switchType !== meta.device.meta.switchType) {
+                            meta.device.meta.switchType = switchType;
+                            meta.deviceExposesChanged();
+                        }
+                    }
+                    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 +921,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 +937,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) {
@@ -870,15 +969,44 @@ const boschExtend = {
                         return { state: { device_mode: value } };
                     }
                     if (key === "switch_type") {
-                        const index = utils.getFromLookup(value, stateSwitchType);
-                        await entity.write("boschSpecific", { switchType: index });
+                        const applyDefaultForSwitchModeAndChildLock = async (endpoint) => {
+                            const switchModeDefault = utils.getFromLookup("coupled", stateSwitchMode);
+                            const childLockDefault = utils.getFromLookup("OFF", stateOffOn);
+                            await endpoint.write("boschSpecific", {
+                                switchMode: switchModeDefault,
+                                childLock: childLockDefault,
+                            });
+                            await endpoint.read("boschSpecific", ["switchMode", "childLock"]);
+                        };
+                        const switchType = utils.getFromLookup(value, stateSwitchType);
+                        await entity.write("boschSpecific", { switchType: switchType });
+                        await entity.read("boschSpecific", ["switchType"]);
+                        await applyDefaultForSwitchModeAndChildLock(entity);
+                        const leftEndpoint = meta.device.getEndpoint(2);
+                        await applyDefaultForSwitchModeAndChildLock(leftEndpoint);
+                        const rightEndpoint = meta.device.getEndpoint(3);
+                        await applyDefaultForSwitchModeAndChildLock(rightEndpoint);
                         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 +1023,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}`);
                     }
@@ -1761,7 +1898,17 @@ exports.definitions = [
         model: "BSP-FZ2",
         vendor: "Bosch",
         description: "Plug compact EU",
-        extend: [m.onOff(), m.electricityMeter({ voltage: false, current: false })],
+        extend: [
+            m.onOff(),
+            m.electricityMeter({
+                voltage: false,
+                current: false,
+                power: { change: 1 },
+                energy: { change: 1 },
+            }),
+            boschExtend.seMeteringCluster(),
+            boschExtend.resetEnergyReading(),
+        ],
         ota: true,
         whiteLabel: [
             { vendor: "Bosch", model: "BSP-EZ2", description: "Plug compact FR", fingerprint: [{ modelID: "RBSH-SP-ZB-FR" }] },
@@ -1834,48 +1981,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,63 +2122,159 @@ 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 = (switchType) => {
+                const exposeList = [];
+                exposeList.push(e.enum("switch_type", ea.ALL, Object.keys(stateSwitchType)).withDescription("Module controlled by a rocker switch or a button"));
+                if (switchType !== "none") {
+                    let supportedActionTypes;
+                    switch (switchType) {
+                        case "button":
+                        case "button_key_change":
+                            supportedActionTypes = [
+                                "press_released_left",
+                                "press_released_right",
+                                "hold_left",
+                                "hold_right",
+                                "hold_released_left",
+                                "hold_released_right",
+                            ];
+                            break;
+                        case "rocker_switch":
+                        case "rocker_switch_key_change":
+                            supportedActionTypes = ["opened_left", "opened_right", "closed_left", "closed_right"];
+                            break;
+                    }
+                    exposeList.push(e.action(supportedActionTypes), e.action_duration());
+                }
+                return exposeList;
+            };
+            const lightExposes = (endpoint, switchType) => {
+                const exposeList = [];
+                exposeList.push(e.switch().withEndpoint(endpoint), e.power_on_behavior().withEndpoint(endpoint), e
+                    .binary("auto_off_enabled", ea.ALL, "ON", "OFF")
+                    .withEndpoint(endpoint)
+                    .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(endpoint));
+                if (switchType !== "none") {
+                    let supportedSwitchModes;
+                    switch (switchType) {
+                        case "button":
+                        case "button_key_change":
+                            supportedSwitchModes = Object.keys(stateSwitchMode);
+                            break;
+                        case "rocker_switch":
+                        case "rocker_switch_key_change":
+                            supportedSwitchModes = Object.keys(stateSwitchMode).filter((switchMode) => switchMode === "coupled" || switchMode === "decoupled");
+                            break;
+                    }
+                    exposeList.push(e
+                        .enum("switch_mode", ea.ALL, supportedSwitchModes)
+                        .withEndpoint(endpoint)
+                        .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that the available options depend on the used switch type."), e.binary("child_lock", ea.ALL, "ON", "OFF").withEndpoint(endpoint).withDescription("Enable/Disable child lock"));
+                }
+                return exposeList;
             };
-            const commonExposes = [
-                e.enum("switch_type", ea.ALL, Object.keys(stateSwitchType)).withDescription("Module controlled by a rocker switch or a button"),
-            ];
-            const lightExposes = [
-                e.switch().withEndpoint("left"),
-                e.switch().withEndpoint("right"),
-                e.power_on_behavior().withEndpoint("left"),
-                e.power_on_behavior().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"),
-            ];
-            const coverExposes = [
-                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
+            const coverExposes = (switchType) => {
+                const exposeList = [];
+                exposeList.push(e.cover_position(), e.enum("motor_state", ea.STATE, Object.keys(stateMotor)).withDescription("Current shutter motor state"), e
                     .numeric("calibration_closing_time", ea.ALL)
                     .withUnit("s")
                     .withDescription("Calibrate shutter closing time")
                     .withValueMin(1)
                     .withValueMax(90)
-                    .withValueStep(0.1),
-                e
+                    .withValueStep(0.1), e
                     .numeric("calibration_opening_time", ea.ALL)
                     .withUnit("s")
                     .withDescription("Calibrate shutter opening time")
                     .withValueMin(1)
                     .withValueMax(90)
-                    .withValueStep(0.1),
-                e
+                    .withValueStep(0.1), e
                     .numeric("calibration_button_hold_time", ea.ALL)
                     .withUnit("s")
                     .withDescription("Time to hold for long press")
                     .withValueMin(0.1)
                     .withValueMax(2)
-                    .withValueStep(0.1),
-                e
+                    .withValueStep(0.1), e
                     .numeric("calibration_motor_start_delay", ea.ALL)
                     .withUnit("s")
                     .withDescription("Delay between command and motor start")
                     .withValueMin(0)
                     .withValueMax(20)
-                    .withValueStep(0.1),
-            ];
+                    .withValueStep(0.1));
+                if (switchType !== "none") {
+                    let supportedSwitchModes;
+                    switch (switchType) {
+                        case "button":
+                        case "button_key_change":
+                            supportedSwitchModes = Object.keys(stateSwitchMode).filter((switchMode) => switchMode === "coupled" || switchMode === "only_long_press_decoupled");
+                            break;
+                        case "rocker_switch":
+                        case "rocker_switch_key_change":
+                            supportedSwitchModes = Object.keys(stateSwitchMode).filter((switchMode) => switchMode === "coupled");
+                            break;
+                    }
+                    exposeList.push(e
+                        .enum("switch_mode", ea.ALL, supportedSwitchModes)
+                        .withDescription("Decouple the switch from the corresponding output to use it for other purposes. Please keep in mind that the available options depend on the used switch type."), e.binary("child_lock", ea.ALL, "ON", "OFF").withDescription("Enable/Disable child lock"));
+                }
+                return exposeList;
+            };
             if (!utils.isDummyDevice(device)) {
                 const deviceModeKey = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "deviceMode");
                 const deviceMode = Object.keys(stateDeviceMode).find((key) => stateDeviceMode[key] === deviceModeKey);
+                const switchTypeKey = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "switchType");
+                const switchType = Object.keys(stateSwitchType).find((key) => stateSwitchType[key] === switchTypeKey);
                 if (deviceMode === "light") {
-                    return [...commonExposes, ...lightExposes];
+                    return [...commonExposes(switchType), ...lightExposes("left", switchType), ...lightExposes("right", switchType)];
                 }
                 if (deviceMode === "shutter") {
-                    return [...commonExposes, ...coverExposes];
+                    return [...commonExposes(switchType), ...coverExposes(switchType)];
                 }
             }
             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"],