zigbee-herdsman-converters 25.8.0 → 25.10.0

package/dist/devices/inovelli.js

@@ -221,7 +221,7 @@ const inovelliExtend = {
             },
             ledEffectComplete: {
                 ID: 0x24,
-                parameters: [{ name: "notificationType", type: zigbee_herdsman_1.Zcl.DataType.UINT8 }],
+                parameters: [{ name: "notificationType", type: zigbee_herdsman_1.Zcl.DataType.INT8 }],
             },
         },
         commandsResponse: {},
@@ -261,9 +261,129 @@ const inovelliExtend = {
             },
         },
     }),
+    inovelliDevice: ({ attrs, supportsLedEffects, supportsButtonTaps, splitValuesByEndpoint = false, }) => {
+        const fromZigbee = [];
+        const toZigbee = [];
+        const exposes = [];
+        if (supportsLedEffects) {
+            fromZigbee.push(fzLocal.led_effect_complete);
+            toZigbee.push(tzLocal.inovelli_led_effect, tzLocal.inovelli_individual_led_effect);
+            exposes.push(exposeLedEffects(), exposeIndividualLedEffects(), exposeLedEffectComplete());
+        }
+        for (const attr of attrs) {
+            fromZigbee.push(fzLocal.inovelli(attr.attributes, attr.clusterName, splitValuesByEndpoint));
+            toZigbee.push(tzLocal.inovelli_parameters(attr.attributes, attr.clusterName), tzLocal.inovelli_parameters_readOnly(attr.attributes, attr.clusterName));
+            attributesToExposeList(attr.attributes, exposes);
+        }
+        if (supportsButtonTaps) {
+            exposes.push(e.action(BUTTON_TAP_SEQUENCES));
+        }
+        const configure = [
+            async (device, coordinatorEndpoint, definition) => {
+                const endpoint = device.getEndpoint(1);
+                await reporting.bind(endpoint, coordinatorEndpoint, [INOVELLI_CLUSTER_NAME]);
+                // Bind for Button Event Reporting
+                const endpoint2 = device.getEndpoint(2);
+                await reporting.bind(endpoint2, coordinatorEndpoint, [INOVELLI_CLUSTER_NAME]);
+                for (const attr of attrs) {
+                    if (!splitValuesByEndpoint) {
+                        await chunkedRead(endpoint, Object.keys(attr.attributes), attr.clusterName);
+                    }
+                    else {
+                        await chunkedRead(endpoint, Object.keys(attr.attributes).flatMap((key) => {
+                            const keysplit = key.split("_");
+                            if (keysplit.length === 2) {
+                                if (Number(keysplit[1]) === 1) {
+                                    return [keysplit[0]];
+                                }
+                                return [];
+                            }
+                            return [key];
+                        }), attr.clusterName);
+                        await chunkedRead(endpoint2, Object.keys(attr.attributes).flatMap((key) => {
+                            const keysplit = key.split("_");
+                            if (keysplit.length === 2) {
+                                if (Number(keysplit[1]) === 2) {
+                                    return [keysplit[0]];
+                                }
+                            }
+                            return [];
+                        }), attr.clusterName);
+                    }
+                }
+            },
+        ];
+        return {
+            fromZigbee,
+            toZigbee,
+            exposes,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    inovelliLight: ({ splitValuesByEndpoint = false } = {}) => {
+        const fromZigbee = [];
+        const bindingList = ["genOnOff"];
+        if (!splitValuesByEndpoint) {
+            fromZigbee.push(fz.on_off, fz.brightness, fz.level_config, fz.power_on_behavior, fz.ignore_basic_report);
+            bindingList.push("genLevelCtrl");
+        }
+        const configure = [
+            async (device, coordinatorEndpoint, definition) => {
+                const endpoint = device.getEndpoint(1);
+                await reporting.bind(endpoint, coordinatorEndpoint, bindingList);
+                await reporting.onOff(endpoint);
+            },
+        ];
+        return {
+            fromZigbee,
+            toZigbee: [
+                tz.on_off,
+                tzLocal.light_onoff_brightness_inovelli,
+                tz.power_on_behavior,
+                tz.ignore_transition,
+                tz.light_brightness_move,
+                tz.light_brightness_step,
+                tz.level_config,
+            ],
+            exposes: [e.light_brightness()],
+            configure,
+            isModernExtend: true,
+        };
+    },
+    inovelliFan: ({ endpointId, splitValuesByEndpoint = false }) => {
+        const fromZigbee = [fzLocal.fan_mode(endpointId), fzLocal.breeze_mode(endpointId)];
+        const toZigbee = [tzLocal.fan_mode(endpointId), tzLocal.breezeMode(endpointId)];
+        const exposes = [e.fan().withState("fan_state").withModes(Object.keys(FAN_MODES)), exposeBreezeMode()];
+        const bindingList = ["genOnOff"];
+        if (!splitValuesByEndpoint) {
+            fromZigbee.push(fzLocal.fan_state);
+            toZigbee.push(tzLocal.fan_state);
+            bindingList.push("genLevelCtrl");
+        }
+        const configure = [
+            async (device, coordinatorEndpoint, definition) => {
+                const endpoint = device.getEndpoint(1);
+                await reporting.bind(endpoint, coordinatorEndpoint, bindingList);
+                await reporting.onOff(endpoint);
+                if (splitValuesByEndpoint) {
+                    const endpoint2 = device.getEndpoint(2);
+                    await reporting.bind(endpoint2, coordinatorEndpoint, bindingList);
+                    await reporting.onOff(endpoint2);
+                }
+            },
+        ];
+        return {
+            fromZigbee,
+            toZigbee,
+            exposes,
+            configure,
+            isModernExtend: true,
+        };
+    },
 };
-const fanModes = { off: 0, low: 2, smart: 4, medium: 86, high: 170, on: 255 };
-const breezemodes = ["off", "low", "medium", "high"];
+const FAN_MODES = { off: 0, low: 2, smart: 4, medium: 86, high: 170, on: 255 };
+const BREEZE_MODES = ["off", "low", "medium", "high"];
 const LED_NOTIFICATION_TYPES = {
     0: "LED_1",
     1: "LED_2",
@@ -273,19 +393,19 @@ const LED_NOTIFICATION_TYPES = {
     5: "LED_6",
     6: "LED_7",
     16: "ALL_LEDS",
-    255: "CONFIG_BUTTON_DOUBLE_PRESS",
+    "-1": "CONFIG_BUTTON_DOUBLE_PRESS",
 };
 const INOVELLI = 0x122f;
 // Converts brightness level to a fan mode
 const intToFanMode = (value) => {
     let selectedMode = "low";
-    if (value >= fanModes.low) {
+    if (value >= FAN_MODES.low) {
         selectedMode = "low";
     }
-    if (value >= fanModes.medium) {
+    if (value >= FAN_MODES.medium) {
         selectedMode = "medium";
     }
-    if (value >= fanModes.high) {
+    if (value >= FAN_MODES.high) {
         selectedMode = "high";
     }
     if (value === 4) {
@@ -1587,7 +1707,7 @@ const tzLocal = {
                 ...meta,
                 message: {
                     ...meta.message,
-                    transition: (!transition.specified ? 0xffff : Math.round(transition.time)) / 10,
+                    transition: (!transition.specified ? 0xffff : transition.time) / 10,
                 },
                 converterOptions: {
                     ctrlbits: 0,
@@ -1604,7 +1724,7 @@ const tzLocal = {
             utils.assertString(value);
             const endpoint = meta.device.getEndpoint(endpointId);
             await endpoint.command("genLevelCtrl", "moveToLevelWithOnOff", {
-                level: fanModes[value],
+                level: FAN_MODES[value],
                 transtime: 0xffff,
             }, utils.getOptions(meta.mapped, entity));
             meta.state[key] = value;
@@ -1828,11 +1948,11 @@ const fzLocal = {
                 if (msg.data.breeze_mode !== undefined) {
                     const bitmasks = [3, 60, 192, 3840, 12288, 245760, 786432, 15728640, 50331648, 1006632960];
                     const raw = msg.data.breeze_mode;
-                    const s1 = breezemodes[raw & bitmasks[0]];
-                    const s2 = breezemodes[(raw & bitmasks[2]) / 64];
-                    const s3 = breezemodes[(raw & bitmasks[4]) / 4096];
-                    const s4 = breezemodes[(raw & bitmasks[6]) / 262144];
-                    const s5 = breezemodes[(raw & bitmasks[8]) / 16777216];
+                    const s1 = BREEZE_MODES[raw & bitmasks[0]];
+                    const s2 = BREEZE_MODES[(raw & bitmasks[2]) / 64];
+                    const s3 = BREEZE_MODES[(raw & bitmasks[4]) / 4096];
+                    const s4 = BREEZE_MODES[(raw & bitmasks[6]) / 262144];
+                    const s5 = BREEZE_MODES[(raw & bitmasks[8]) / 16777216];
                     const d1 = ((raw & bitmasks[1]) / 4) * 5;
                     const d2 = ((raw & bitmasks[3]) / 256) * 5;
                     const d3 = ((raw & bitmasks[5]) / 16384) * 5;
@@ -1948,36 +2068,11 @@ const exposeMMWaveControl = () => {
 };
 const exposeLedEffectComplete = () => {
     return e
-        .enum("notificationComplete", ea.STATE_GET, Object.values(LED_NOTIFICATION_TYPES))
+        .enum("notificationComplete", ea.STATE, Object.values(LED_NOTIFICATION_TYPES))
         .withDescription("Indication that a specific notification has completed.")
         .withCategory("diagnostic");
 };
-const exposesListVZM30 = [e.light_brightness(), exposeLedEffects(), exposeIndividualLedEffects(), exposeLedEffectComplete()];
-const exposesListVZM31 = [e.light_brightness(), exposeLedEffects(), exposeIndividualLedEffects(), exposeLedEffectComplete()];
-const exposesListVZM32 = [
-    e.light_brightness(),
-    exposeLedEffects(),
-    exposeIndividualLedEffects(),
-    exposeMMWaveControl(),
-    exposeLedEffectComplete(),
-];
-const exposesListVZM35 = [
-    e.fan().withState("fan_state").withModes(Object.keys(fanModes)),
-    exposeLedEffects(),
-    exposeIndividualLedEffects(),
-    exposeBreezeMode(),
-    exposeLedEffectComplete(),
-];
-const exposesListVZM36 = [e.light_brightness(), e.fan().withState("fan_state").withModes(Object.keys(fanModes)), exposeBreezeMode()];
-// Populate exposes list from the attributes description
-attributesToExposeList(VZM30_ATTRIBUTES, exposesListVZM30);
-attributesToExposeList(VZM31_ATTRIBUTES, exposesListVZM31);
-attributesToExposeList(VZM32_ATTRIBUTES, exposesListVZM32);
-attributesToExposeList(VZM32_MMWAVE_ATTRIBUTES, exposesListVZM32);
-attributesToExposeList(VZM35_ATTRIBUTES, exposesListVZM35);
-attributesToExposeList(VZM36_ATTRIBUTES, exposesListVZM36);
-// Put actions at the bottom of ui
-const buttonTapSequences = [
+const BUTTON_TAP_SEQUENCES = [
     "down_single",
     "up_single",
     "config_single",
@@ -2000,10 +2095,6 @@ const buttonTapSequences = [
     "up_quintuple",
     "config_quintuple",
 ];
-exposesListVZM30.push(e.action(buttonTapSequences));
-exposesListVZM31.push(e.action(buttonTapSequences));
-exposesListVZM32.push(e.action(buttonTapSequences));
-exposesListVZM35.push(e.action(buttonTapSequences));
 /*
  * Inovelli devices have a huge number of attributes. Calling endpoint.read() in a single call
  * for all attributes causes timeouts even with the timeout set to an absurdly high number (2 minutes)
@@ -2021,62 +2112,43 @@ exports.definitions = [
         model: "VZM30-SN",
         vendor: "Inovelli",
         description: "On/off switch",
-        exposes: exposesListVZM30.concat(m.identify().exposes),
         extend: [
             m.deviceEndpoints({
                 endpoints: { "1": 1, "2": 2, "3": 3, "4": 4 },
                 multiEndpointSkip: ["state", "voltage", "power", "current", "energy", "brightness", "temperature", "humidity"],
             }),
+            inovelliExtend.inovelliLight(),
+            inovelliExtend.inovelliDevice({
+                attrs: [{ attributes: VZM30_ATTRIBUTES, clusterName: INOVELLI_CLUSTER_NAME }],
+                supportsLedEffects: true,
+                supportsButtonTaps: true,
+            }),
             inovelliExtend.addCustomClusterInovelli(),
+            m.identify(),
             m.temperature(),
             m.humidity(),
-            m.electricityMeter(),
-        ],
-        toZigbee: [
-            tzLocal.light_onoff_brightness_inovelli,
-            tz.power_on_behavior,
-            tz.ignore_transition,
-            tz.identify,
-            tz.light_brightness_move,
-            tz.light_brightness_step,
-            tz.level_config,
-            tzLocal.inovelli_led_effect,
-            tzLocal.inovelli_individual_led_effect,
-            tzLocal.inovelli_parameters(VZM30_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            tzLocal.inovelli_parameters_readOnly(VZM30_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-        ],
-        fromZigbee: [
-            fz.on_off,
-            fz.brightness,
-            fz.level_config,
-            fz.power_on_behavior,
-            fz.ignore_basic_report,
-            fzLocal.inovelli(VZM30_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            fzLocal.led_effect_complete,
+            m.electricityMeter({ energy: { divisor: 1000 } }),
         ],
         ota: true,
-        configure: async (device, coordinatorEndpoint) => {
-            const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "genLevelCtrl"]);
-            await reporting.onOff(endpoint);
-            await chunkedRead(endpoint, Object.keys(VZM30_ATTRIBUTES), INOVELLI_CLUSTER_NAME);
-            // Bind for Button Event Reporting
-            const endpoint2 = device.getEndpoint(2);
-            await reporting.bind(endpoint2, coordinatorEndpoint, [INOVELLI_CLUSTER_NAME]);
-        },
     },
     {
         zigbeeModel: ["VZM31-SN"],
         model: "VZM31-SN",
         vendor: "Inovelli",
         description: "2-in-1 switch + dimmer",
-        exposes: exposesListVZM31.concat(m.identify().exposes),
         extend: [
             m.deviceEndpoints({
                 endpoints: { "1": 1, "2": 2, "3": 3 },
                 multiEndpointSkip: ["state", "power", "energy", "brightness"],
             }),
+            inovelliExtend.inovelliLight(),
+            inovelliExtend.inovelliDevice({
+                attrs: [{ attributes: VZM31_ATTRIBUTES, clusterName: INOVELLI_CLUSTER_NAME }],
+                supportsLedEffects: true,
+                supportsButtonTaps: true,
+            }),
             inovelliExtend.addCustomClusterInovelli(),
+            m.identify(),
             m.electricityMeter({
                 current: false,
                 voltage: false,
@@ -2084,184 +2156,82 @@ exports.definitions = [
                 energy: { min: 15, max: 3600, change: 0 },
             }),
         ],
-        toZigbee: [
-            tzLocal.light_onoff_brightness_inovelli,
-            tz.power_on_behavior,
-            tz.ignore_transition,
-            tz.identify,
-            tz.light_brightness_move,
-            tz.light_brightness_step,
-            tz.level_config,
-            tzLocal.inovelli_led_effect,
-            tzLocal.inovelli_individual_led_effect,
-            tzLocal.inovelli_parameters(VZM31_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            tzLocal.inovelli_parameters_readOnly(VZM31_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-        ],
-        fromZigbee: [
-            fz.on_off,
-            fz.brightness,
-            fz.level_config,
-            fz.power_on_behavior,
-            fz.ignore_basic_report,
-            fzLocal.inovelli(VZM31_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            fzLocal.led_effect_complete,
-        ],
         ota: true,
-        configure: async (device, coordinatorEndpoint) => {
-            const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "genLevelCtrl", INOVELLI_CLUSTER_NAME]);
-            await reporting.onOff(endpoint);
-            await chunkedRead(endpoint, Object.keys(VZM31_ATTRIBUTES), INOVELLI_CLUSTER_NAME);
-            // Bind for Button Event Reporting
-            const endpoint2 = device.getEndpoint(2);
-            await reporting.bind(endpoint2, coordinatorEndpoint, [INOVELLI_CLUSTER_NAME]);
-        },
     },
     {
         zigbeeModel: ["VZM32-SN"],
         model: "VZM32-SN",
         vendor: "Inovelli",
         description: "mmWave Zigbee Dimmer",
-        exposes: exposesListVZM32.concat(m.identify().exposes),
+        exposes: [exposeMMWaveControl()],
         extend: [
             m.deviceEndpoints({
                 endpoints: { "1": 1, "2": 2, "3": 3 },
                 multiEndpointSkip: ["state", "voltage", "power", "current", "energy", "brightness", "illuminance", "occupancy"],
             }),
+            inovelliExtend.inovelliLight(),
+            inovelliExtend.inovelliDevice({
+                attrs: [
+                    { attributes: VZM32_ATTRIBUTES, clusterName: INOVELLI_CLUSTER_NAME },
+                    { attributes: VZM32_MMWAVE_ATTRIBUTES, clusterName: INOVELLI_MMWAVE_CLUSTER_NAME },
+                ],
+                supportsLedEffects: true,
+                supportsButtonTaps: true,
+            }),
             inovelliExtend.addCustomClusterInovelli(),
             inovelliExtend.addCustomMMWaveClusterInovelli(),
-            m.electricityMeter(),
+            m.identify(),
+            m.electricityMeter({
+                // Current and voltage were removed in version 0.8 of the firmware and expected to be restored in the future
+                current: false,
+                voltage: false,
+                energy: { divisor: 1000 },
+            }),
             m.illuminance(),
             m.occupancy(),
         ],
-        toZigbee: [
-            tzLocal.light_onoff_brightness_inovelli,
-            tz.power_on_behavior,
-            tz.ignore_transition,
-            tz.identify,
-            tz.light_brightness_move,
-            tz.light_brightness_step,
-            tz.level_config,
-            tzLocal.inovelli_led_effect,
-            tzLocal.inovelli_individual_led_effect,
-            tzLocal.inovelli_mmwave_control_commands,
-            tzLocal.inovelli_parameters(VZM32_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            tzLocal.inovelli_parameters_readOnly(VZM32_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            tzLocal.inovelli_parameters(VZM32_MMWAVE_ATTRIBUTES, INOVELLI_MMWAVE_CLUSTER_NAME),
-            tzLocal.inovelli_parameters_readOnly(VZM32_MMWAVE_ATTRIBUTES, INOVELLI_MMWAVE_CLUSTER_NAME),
-        ],
-        fromZigbee: [
-            fz.on_off,
-            fz.brightness,
-            fz.level_config,
-            fz.power_on_behavior,
-            fz.ignore_basic_report,
-            fzLocal.inovelli(VZM32_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            fzLocal.inovelli(VZM32_MMWAVE_ATTRIBUTES, INOVELLI_MMWAVE_CLUSTER_NAME),
-            fzLocal.led_effect_complete,
-        ],
+        toZigbee: [tzLocal.inovelli_mmwave_control_commands],
         ota: true,
-        configure: async (device, coordinatorEndpoint) => {
-            const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "genLevelCtrl", INOVELLI_CLUSTER_NAME]);
-            await reporting.onOff(endpoint);
-            await chunkedRead(endpoint, Object.keys(VZM32_ATTRIBUTES), INOVELLI_CLUSTER_NAME);
-            await chunkedRead(endpoint, Object.keys(VZM32_MMWAVE_ATTRIBUTES), INOVELLI_MMWAVE_CLUSTER_NAME);
-            // Bind for Button Event Reporting
-            const endpoint2 = device.getEndpoint(2);
-            await reporting.bind(endpoint2, coordinatorEndpoint, [INOVELLI_CLUSTER_NAME]);
-        },
     },
     {
         zigbeeModel: ["VZM35-SN"],
         model: "VZM35-SN",
         vendor: "Inovelli",
         description: "Fan controller",
-        fromZigbee: [
-            fzLocal.fan_state,
-            fzLocal.fan_mode(1),
-            fzLocal.breeze_mode(1),
-            fzLocal.inovelli(VZM35_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            fzLocal.led_effect_complete,
-        ],
-        toZigbee: [
-            tz.identify,
-            tzLocal.fan_state,
-            tzLocal.fan_mode(1),
-            tzLocal.inovelli_led_effect,
-            tzLocal.inovelli_individual_led_effect,
-            tzLocal.inovelli_parameters(VZM35_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            tzLocal.inovelli_parameters_readOnly(VZM35_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            tzLocal.breezeMode(1),
+        extend: [
+            inovelliExtend.inovelliFan({ endpointId: 1 }),
+            inovelliExtend.inovelliDevice({
+                attrs: [{ attributes: VZM35_ATTRIBUTES, clusterName: INOVELLI_CLUSTER_NAME }],
+                supportsLedEffects: true,
+                supportsButtonTaps: true,
+            }),
+            inovelliExtend.addCustomClusterInovelli(),
+            m.identify(),
         ],
-        exposes: exposesListVZM35.concat(m.identify().exposes),
-        extend: [inovelliExtend.addCustomClusterInovelli()],
         ota: true,
-        configure: async (device, coordinatorEndpoint) => {
-            const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "genLevelCtrl", INOVELLI_CLUSTER_NAME]);
-            await chunkedRead(endpoint, Object.keys(VZM35_ATTRIBUTES), INOVELLI_CLUSTER_NAME);
-            // Bind for Button Event Reporting
-            const endpoint2 = device.getEndpoint(2);
-            await reporting.bind(endpoint2, coordinatorEndpoint, [INOVELLI_CLUSTER_NAME]);
-        },
     },
     {
         zigbeeModel: ["VZM36"],
         model: "VZM36",
         vendor: "Inovelli",
         description: "Fan canopy module",
-        fromZigbee: [
-            fzLocal.brightness,
-            fzLocal.vzm36_fan_light_state,
-            fzLocal.fan_mode(2),
-            fzLocal.breeze_mode(2),
-            fzLocal.inovelli(VZM36_ATTRIBUTES, INOVELLI_CLUSTER_NAME, true),
-        ],
+        fromZigbee: [fzLocal.brightness, fzLocal.vzm36_fan_light_state],
         toZigbee: [
-            tz.identify,
             tzLocal.vzm36_fan_on_off, // Need to use VZM36 specific converter
-            tz.light_brightness_move,
-            tz.light_brightness_step,
-            tz.level_config,
-            tzLocal.fan_mode(2),
-            tzLocal.light_onoff_brightness_inovelli,
-            tzLocal.inovelli_parameters(VZM36_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            tzLocal.inovelli_parameters_readOnly(VZM36_ATTRIBUTES, INOVELLI_CLUSTER_NAME),
-            tzLocal.breezeMode(2),
         ],
-        exposes: exposesListVZM36.concat(m.identify().exposes),
-        extend: [inovelliExtend.addCustomClusterInovelli()],
+        extend: [
+            inovelliExtend.inovelliLight({ splitValuesByEndpoint: true }),
+            inovelliExtend.inovelliFan({ endpointId: 2, splitValuesByEndpoint: true }),
+            inovelliExtend.inovelliDevice({
+                attrs: [{ attributes: VZM36_ATTRIBUTES, clusterName: INOVELLI_CLUSTER_NAME }],
+                supportsLedEffects: false,
+                splitValuesByEndpoint: true,
+                supportsButtonTaps: false,
+            }),
+            inovelliExtend.addCustomClusterInovelli(),
+            m.identify(),
+        ],
         ota: true,
-        // The configure method below is needed to make the device reports on/off state changes
-        // when the device is controlled manually through the button on it.
-        configure: async (device, coordinatorEndpoint) => {
-            const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff"]);
-            await reporting.onOff(endpoint);
-            await chunkedRead(endpoint, Object.keys(VZM36_ATTRIBUTES).flatMap((key) => {
-                const keysplit = key.split("_");
-                if (keysplit.length === 2) {
-                    if (Number(keysplit[1]) === 1) {
-                        return [keysplit[0]];
-                    }
-                    return [];
-                }
-                return [key];
-            }), INOVELLI_CLUSTER_NAME);
-            const endpoint2 = device.getEndpoint(2);
-            await reporting.bind(endpoint2, coordinatorEndpoint, ["genOnOff"]);
-            await reporting.onOff(endpoint2);
-            await chunkedRead(endpoint2, Object.keys(VZM36_ATTRIBUTES).flatMap((key) => {
-                const keysplit = key.split("_");
-                if (keysplit.length === 2) {
-                    if (Number(keysplit[1]) === 2) {
-                        return [keysplit[0]];
-                    }
-                }
-                return [];
-            }), INOVELLI_CLUSTER_NAME);
-        },
     },
 ];
 //# sourceMappingURL=inovelli.js.map