zigbee-herdsman-converters 25.28.0 → 25.30.0

package/dist/lib/bosch.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.boschBsenExtend = exports.boschBsirExtend = exports.boschBmctExtend = 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"));
@@ -48,88 +48,62 @@ const e = exposes.presets;
 const ea = exposes.access;
 const NS = "zhc:bosch";
 exports.manufacturerOptions = { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.ROBERT_BOSCH_GMBH };
-exports.boschBmctExtend = {
-    switchMode: (args) => {
-        const { endpoint, deviceModeLookup, switchModeLookup, switchTypeLookup } = args;
-        const expose = (device, options) => {
-            if (utils.isDummyDevice(device)) {
-                return [];
-            }
-            const switchTypeKey = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "switchType") ?? 0x00;
-            const selectedSwitchType = utils.getFromLookupByValue(switchTypeKey, switchTypeLookup);
-            if (selectedSwitchType === "none") {
-                return [];
-            }
-            let supportedSwitchModes = Object.keys(switchModeLookup);
-            if (device.modelID === "RBSH-MMS-ZB-EU") {
-                const deviceModeKey = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "deviceMode");
-                const deviceMode = utils.getFromLookupByValue(deviceModeKey, deviceModeLookup);
-                if (deviceMode === "light") {
-                    if (selectedSwitchType.includes("rocker_switch")) {
-                        supportedSwitchModes = supportedSwitchModes.filter((switchMode) => switchMode === "coupled" || switchMode === "decoupled");
-                    }
+exports.boschGeneralExtend = {
+    handleZclVersionReadRequest: () => {
+        const onEvent = [
+            (event) => {
+                if (event.type !== "deviceAnnounce") {
+                    return;
                 }
-                if (deviceMode === "shutter") {
-                    if (selectedSwitchType.includes("button")) {
-                        supportedSwitchModes = supportedSwitchModes.filter((switchMode) => switchMode === "coupled" || switchMode === "only_long_press_decoupled");
-                    }
-                    else if (selectedSwitchType.includes("rocker_switch")) {
-                        supportedSwitchModes = supportedSwitchModes.filter((switchMode) => switchMode === "coupled");
+                event.data.device.customReadResponse = (frame, endpoint) => {
+                    const isZclVersionRequest = frame.isCluster("genBasic") && frame.payload.find((i) => i.attrId === 0);
+                    if (!isZclVersionRequest) {
+                        return false;
                     }
-                }
-            }
-            const switchModeExpose = 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 may depend on the used switch type.")
-                .withCategory("config");
-            if (endpoint !== undefined) {
-                switchModeExpose.withEndpoint(endpoint.toString());
-            }
-            return [switchModeExpose];
+                    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;
+                };
+            },
+        ];
+        return {
+            onEvent,
+            isModernExtend: true,
         };
-        const fromZigbee = [
-            {
-                cluster: "boschSpecific",
-                type: ["attributeReport", "readResponse"],
-                convert: (model, msg, publish, options, meta) => {
-                    const result = {};
-                    const data = msg.data;
-                    if (data.switchMode !== undefined) {
-                        const property = utils.postfixWithEndpointName("switch_mode", msg, model, meta);
-                        result[property] = utils.getFromLookupByValue(data.switchMode, switchModeLookup);
-                    }
-                    return result;
-                },
+    },
+    customSeMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
+        ID: zigbee_herdsman_1.Zcl.Clusters.seMetering.ID,
+        attributes: {},
+        commands: {
+            resetEnergyMeters: {
+                ID: 0x80,
+                parameters: [],
             },
+        },
+        commandsResponse: {},
+    }),
+    resetEnergyMeters: () => {
+        const exposes = [
+            e
+                .enum("reset_energy_meters", ea.SET, ["reset"])
+                .withDescription("Triggers the reset of all energy meters on the device to 0 kWh")
+                .withCategory("config"),
         ];
         const toZigbee = [
             {
-                key: ["switch_mode"],
+                key: ["reset_energy_meters"],
                 convertSet: async (entity, key, value, meta) => {
-                    if (key === "switch_mode") {
-                        const index = utils.getFromLookup(value, switchModeLookup);
-                        await entity.write("boschSpecific", { switchMode: index });
-                        return { state: { switch_mode: value } };
-                    }
-                },
-                convertGet: async (entity, key, meta) => {
-                    if (key === "switch_mode") {
-                        await entity.read("boschSpecific", ["switchMode"]);
-                    }
+                    await entity.command("seMetering", "resetEnergyMeters", {}, exports.manufacturerOptions);
                 },
             },
         ];
-        const configure = [
-            async (device, coordinatorEndpoint, definition) => {
-                const desiredEndpoint = device.getEndpoint(endpoint ?? 1);
-                await desiredEndpoint.read("boschSpecific", ["switchMode"]);
-            },
-        ];
         return {
-            exposes: [expose],
-            fromZigbee,
+            exposes,
             toZigbee,
-            configure,
             isModernExtend: true,
         };
     },
@@ -144,7 +118,7 @@ exports.boschBmctExtend = {
                 return [];
             }
             if (device.modelID === "RBSH-MMR-ZB-EU") {
-                const pulsedModeEnabled = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "pulseLength") !== 0;
+                const pulsedModeEnabled = device.getEndpoint(1).getClusterAttributeValue("boschEnergyDevice", "pulseLength") !== 0;
                 if (pulsedModeEnabled) {
                     return [];
                 }
@@ -161,7 +135,7 @@ exports.boschBmctExtend = {
                 .withUnit("min")
                 .withValueMin(0)
                 .withValueMax(720)
-                .withValueStep(1)
+                .withValueStep(0.5)
                 .withCategory("config");
             if (endpoint !== undefined) {
                 autoOffEnabledExpose.withEndpoint(endpoint.toString());
@@ -171,7 +145,7 @@ exports.boschBmctExtend = {
         };
         const fromZigbee = [
             {
-                cluster: "boschSpecific",
+                cluster: "boschEnergyDevice",
                 type: ["attributeReport", "readResponse"],
                 convert: (model, msg, publish, options, meta) => {
                     const result = {};
@@ -182,7 +156,7 @@ exports.boschBmctExtend = {
                     }
                     if (data.autoOffTime !== undefined) {
                         const property = utils.postfixWithEndpointName("auto_off_time", msg, model, meta);
-                        result[property] = msg.data.autoOffTime / 60;
+                        result[property] = data.autoOffTime / 60;
                     }
                     return result;
                 },
@@ -194,20 +168,108 @@ exports.boschBmctExtend = {
                 convertSet: async (entity, key, value, meta) => {
                     if (key === "auto_off_enabled") {
                         const selectedState = utils.getFromLookup(value, offOnLookup);
-                        await entity.write("boschSpecific", { autoOffEnabled: selectedState });
+                        await entity.write("boschEnergyDevice", {
+                            autoOffEnabled: utils.toNumber(selectedState),
+                        });
                         return { state: { auto_off_enabled: value } };
                     }
                     if (key === "auto_off_time") {
-                        await entity.write("boschSpecific", { autoOffTime: (0, utils_1.toNumber)(value) * 60 });
+                        await entity.write("boschEnergyDevice", {
+                            autoOffTime: (0, utils_1.toNumber)(value) * 60,
+                        });
                         return { state: { auto_off_time: value } };
                     }
                 },
                 convertGet: async (entity, key, meta) => {
                     if (key === "auto_off_enabled") {
-                        await entity.read("boschSpecific", ["autoOffEnabled"]);
+                        await entity.read("boschEnergyDevice", ["autoOffEnabled"]);
                     }
                     if (key === "auto_off_time") {
-                        await entity.read("boschSpecific", ["autoOffTime"]);
+                        await entity.read("boschEnergyDevice", ["autoOffTime"]);
+                    }
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForBinding("boschEnergyDevice", "input", endpoint ? [endpoint.toString()] : null),
+            m.setupConfigureForReading("boschEnergyDevice", ["autoOffEnabled", "autoOffTime"], endpoint ? [endpoint.toString()] : null),
+        ];
+        return {
+            exposes: [expose],
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+};
+exports.boschBmctExtend = {
+    switchMode: (args) => {
+        const { endpoint, deviceModeLookup, switchModeLookup, switchTypeLookup } = args;
+        const expose = (device, options) => {
+            if (utils.isDummyDevice(device)) {
+                return [];
+            }
+            const switchTypeKey = device.getEndpoint(1).getClusterAttributeValue("boschEnergyDevice", "switchType") ?? 0x00;
+            const selectedSwitchType = utils.getFromLookupByValue(switchTypeKey, switchTypeLookup);
+            if (selectedSwitchType === "none") {
+                return [];
+            }
+            let supportedSwitchModes = Object.keys(switchModeLookup);
+            if (device.modelID === "RBSH-MMS-ZB-EU") {
+                const deviceModeKey = device.getEndpoint(1).getClusterAttributeValue("boschEnergyDevice", "deviceMode");
+                const deviceMode = utils.getFromLookupByValue(deviceModeKey, deviceModeLookup);
+                if (deviceMode === "light") {
+                    if (selectedSwitchType.includes("rocker_switch")) {
+                        supportedSwitchModes = supportedSwitchModes.filter((switchMode) => switchMode === "coupled" || switchMode === "decoupled");
+                    }
+                }
+                if (deviceMode === "shutter") {
+                    if (selectedSwitchType.includes("button")) {
+                        supportedSwitchModes = supportedSwitchModes.filter((switchMode) => switchMode === "coupled" || switchMode === "only_long_press_decoupled");
+                    }
+                    else if (selectedSwitchType.includes("rocker_switch")) {
+                        supportedSwitchModes = supportedSwitchModes.filter((switchMode) => switchMode === "coupled");
+                    }
+                }
+            }
+            const switchModeExpose = 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 may depend on the used switch type.")
+                .withCategory("config");
+            if (endpoint !== undefined) {
+                switchModeExpose.withEndpoint(endpoint.toString());
+            }
+            return [switchModeExpose];
+        };
+        const fromZigbee = [
+            {
+                cluster: "boschEnergyDevice",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.switchMode !== undefined) {
+                        const property = utils.postfixWithEndpointName("switch_mode", msg, model, meta);
+                        result[property] = utils.getFromLookupByValue(data.switchMode, switchModeLookup);
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["switch_mode"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (key === "switch_mode") {
+                        const index = utils.getFromLookup(value, switchModeLookup);
+                        await entity.write("boschEnergyDevice", { switchMode: index });
+                        return { state: { switch_mode: value } };
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    if (key === "switch_mode") {
+                        await entity.read("boschEnergyDevice", ["switchMode"]);
                     }
                 },
             },
@@ -215,7 +277,7 @@ exports.boschBmctExtend = {
         const configure = [
             async (device, coordinatorEndpoint, definition) => {
                 const desiredEndpoint = device.getEndpoint(endpoint ?? 1);
-                await desiredEndpoint.read("boschSpecific", ["autoOffEnabled", "autoOffTime"]);
+                await desiredEndpoint.read("boschEnergyDevice", ["switchMode"]);
             },
         ];
         return {
@@ -236,7 +298,7 @@ exports.boschBmctExtend = {
             if (utils.isDummyDevice(device)) {
                 return [];
             }
-            const currentSwitchType = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "switchType") ?? 0x00;
+            const currentSwitchType = device.getEndpoint(1).getClusterAttributeValue("boschEnergyDevice", "switchType") ?? 0x00;
             if (currentSwitchType === 0) {
                 return [];
             }
@@ -251,7 +313,7 @@ exports.boschBmctExtend = {
         };
         const fromZigbee = [
             {
-                cluster: "boschSpecific",
+                cluster: "boschEnergyDevice",
                 type: ["attributeReport", "readResponse"],
                 convert: (model, msg, publish, options, meta) => {
                     const result = {};
@@ -270,13 +332,13 @@ exports.boschBmctExtend = {
                 convertSet: async (entity, key, value, meta) => {
                     if (key === "child_lock") {
                         const selectedMode = utils.getFromLookup(value, childLockLookup);
-                        await entity.write("boschSpecific", { childLock: selectedMode });
+                        await entity.write("boschEnergyDevice", { childLock: selectedMode });
                         return { state: { child_lock: value } };
                     }
                 },
                 convertGet: async (entity, key, meta) => {
                     if (key === "child_lock") {
-                        await entity.read("boschSpecific", ["childLock"]);
+                        await entity.read("boschEnergyDevice", ["childLock"]);
                     }
                 },
             },
@@ -284,7 +346,7 @@ exports.boschBmctExtend = {
         const configure = [
             async (device, coordinatorEndpoint, definition) => {
                 const desiredEndpoint = device.getEndpoint(endpoint ?? 1);
-                await desiredEndpoint.read("boschSpecific", ["childLock"]);
+                await desiredEndpoint.read("boschEnergyDevice", ["childLock"]);
             },
         ];
         return {
@@ -297,7 +359,7 @@ exports.boschBmctExtend = {
     },
     actuatorType: () => m.enumLookup({
         name: "actuator_type",
-        cluster: "boschSpecific",
+        cluster: "boschEnergyDevice",
         attribute: "actuatorType",
         description: "Select the appropriate actuator type so that the connected device can be controlled correctly.",
         lookup: {
@@ -308,7 +370,7 @@ exports.boschBmctExtend = {
     }),
     dimmerType: () => m.enumLookup({
         name: "dimmer_type",
-        cluster: "boschSpecific",
+        cluster: "boschEnergyDevice",
         attribute: "dimmerType",
         description: "Select the appropriate dimmer type for your lamps. Make sure that you are only using dimmable lamps.",
         lookup: {
@@ -340,7 +402,7 @@ exports.boschBmctExtend = {
         };
         const fromZigbee = [
             {
-                cluster: "boschSpecific",
+                cluster: "boschEnergyDevice",
                 type: ["attributeReport", "readResponse"],
                 convert: (model, msg, publish, options, meta) => {
                     const result = {};
@@ -361,29 +423,33 @@ exports.boschBmctExtend = {
                 convertSet: async (entity, key, value, meta) => {
                     if (key === "minimum_brightness") {
                         const newMinimumBrightness = (0, utils_1.toNumber)(value);
-                        const currentState = await entity.read("boschSpecific", ["maximumBrightness"]);
+                        const currentState = await entity.read("boschEnergyDevice", ["maximumBrightness"]);
                         if (newMinimumBrightness >= currentState.maximumBrightness) {
                             throw new Error("The minimum brightness must be lower than the maximum brightness!");
                         }
-                        await entity.write("boschSpecific", { minimumBrightness: newMinimumBrightness });
+                        await entity.write("boschEnergyDevice", {
+                            minimumBrightness: newMinimumBrightness,
+                        });
                         return { state: { minimum_brightness: value } };
                     }
                     if (key === "maximum_brightness") {
                         const newMaximumBrightness = (0, utils_1.toNumber)(value);
-                        const currentState = await entity.read("boschSpecific", ["minimumBrightness"]);
+                        const currentState = await entity.read("boschEnergyDevice", ["minimumBrightness"]);
                         if (newMaximumBrightness <= currentState.minimumBrightness) {
                             throw new Error("The maximum brightness must be higher than the minimum brightness!");
                         }
-                        await entity.write("boschSpecific", { maximumBrightness: newMaximumBrightness });
+                        await entity.write("boschEnergyDevice", {
+                            maximumBrightness: newMaximumBrightness,
+                        });
                         return { state: { maximum_brightness: value } };
                     }
                 },
                 convertGet: async (entity, key, meta) => {
                     if (key === "minimum_brightness") {
-                        await entity.read("boschSpecific", ["minimumBrightness"]);
+                        await entity.read("boschEnergyDevice", ["minimumBrightness"]);
                     }
                     if (key === "maximum_brightness") {
-                        await entity.read("boschSpecific", ["maximumBrightness"]);
+                        await entity.read("boschEnergyDevice", ["maximumBrightness"]);
                     }
                 },
             },
@@ -391,7 +457,7 @@ exports.boschBmctExtend = {
         const configure = [
             async (device, coordinatorEndpoint, definition) => {
                 const endpoint = device.getEndpoint(1);
-                await endpoint.read("boschSpecific", ["minimumBrightness", "maximumBrightness"]);
+                await endpoint.read("boschEnergyDevice", ["minimumBrightness", "maximumBrightness"]);
             },
         ];
         return {
@@ -425,14 +491,14 @@ exports.boschBmctExtend = {
                             const newPulseLength = value === utils.getFromLookupByValue(0x00, deviceModesLookup) ? 0 : 10;
                             const endpoint = meta.device.getEndpoint(1);
                             if (newPulseLength > 0) {
-                                await endpoint.write("boschSpecific", {
+                                await endpoint.write("boschEnergyDevice", {
                                     switchType: 0x05,
                                     switchMode: 0x00,
                                     childLock: 0x00,
                                     autoOffEnabled: 0x00,
                                     autoOffTime: 0,
                                 });
-                                await endpoint.read("boschSpecific", [
+                                await endpoint.read("boschEnergyDevice", [
                                     "switchType",
                                     "switchMode",
                                     "childLock",
@@ -441,15 +507,21 @@ exports.boschBmctExtend = {
                                 ]);
                             }
                             else {
-                                await endpoint.write("boschSpecific", {
+                                await endpoint.write("boschEnergyDevice", {
                                     switchType: 0x00,
                                     switchMode: 0x00,
                                     childLock: 0x00,
                                 });
-                                await endpoint.read("boschSpecific", ["switchType", "switchMode", "childLock"]);
+                                await endpoint.read("boschEnergyDevice", [
+                                    "switchType",
+                                    "switchMode",
+                                    "childLock",
+                                ]);
                             }
-                            await endpoint.write("boschSpecific", { pulseLength: newPulseLength });
-                            await endpoint.read("boschSpecific", ["pulseLength"]);
+                            await endpoint.write("boschEnergyDevice", {
+                                pulseLength: newPulseLength,
+                            });
+                            await endpoint.read("boschEnergyDevice", ["pulseLength"]);
                         }
                         return { state: { device_mode: value } };
                     }
@@ -468,7 +540,7 @@ exports.boschBmctExtend = {
             if (utils.isDummyDevice(device)) {
                 return [];
             }
-            if (device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "pulseLength") === 0) {
+            if (device.getEndpoint(1).getClusterAttributeValue("boschEnergyDevice", "pulseLength") === 0) {
                 return [];
             }
             const pulseLengthExpose = e
@@ -484,7 +556,7 @@ exports.boschBmctExtend = {
         };
         const fromZigbee = [
             {
-                cluster: "boschSpecific",
+                cluster: "boschEnergyDevice",
                 type: ["attributeReport", "readResponse"],
                 convert: (model, msg, publish, options, meta) => {
                     const result = {};
@@ -516,13 +588,15 @@ exports.boschBmctExtend = {
                 convertSet: async (entity, key, value, meta) => {
                     if (key === "pulse_length") {
                         const selectedPulseLength = (0, utils_1.toNumber)(value) * 10;
-                        await entity.write("boschSpecific", { pulseLength: selectedPulseLength });
+                        await entity.write("boschEnergyDevice", {
+                            pulseLength: selectedPulseLength,
+                        });
                         return { state: { pulse_length: value } };
                     }
                 },
                 convertGet: async (entity, key, meta) => {
                     if (key === "pulse_length") {
-                        await entity.read("boschSpecific", ["pulseLength"]);
+                        await entity.read("boschEnergyDevice", ["pulseLength"]);
                     }
                 },
             },
@@ -530,7 +604,7 @@ exports.boschBmctExtend = {
         const configure = [
             async (device, coordinatorEndpoint, definition) => {
                 const endpoint = device.getEndpoint(1);
-                await endpoint.read("boschSpecific", ["pulseLength"]);
+                await endpoint.read("boschEnergyDevice", ["pulseLength"]);
             },
         ];
         return {
@@ -549,7 +623,7 @@ exports.boschBmctExtend = {
             }
             let supportedSwitchTypes = Object.keys(switchTypeLookup);
             if (device.modelID === "RBSH-MMR-ZB-EU") {
-                const pulseModeActive = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "pulseLength") > 0;
+                const pulseModeActive = device.getEndpoint(1).getClusterAttributeValue("boschEnergyDevice", "pulseLength") > 0;
                 if (pulseModeActive) {
                     supportedSwitchTypes = Object.keys(switchTypeLookup).filter((switchType) => switchType !== utils.getFromLookup("rocker_switch", switchTypeLookup));
                 }
@@ -563,7 +637,7 @@ exports.boschBmctExtend = {
         };
         const fromZigbee = [
             {
-                cluster: "boschSpecific",
+                cluster: "boschEnergyDevice",
                 type: ["attributeReport", "readResponse"],
                 convert: (model, msg, publish, options, meta) => {
                     const result = {};
@@ -587,23 +661,25 @@ exports.boschBmctExtend = {
                     if (key === "switch_type") {
                         const selectedSwitchType = utils.getFromLookup(value, switchTypeLookup);
                         if (meta.device.meta.switchType !== selectedSwitchType) {
-                            const endpoints = meta.device.endpoints.filter((e) => e.supportsInputCluster("boschSpecific"));
+                            const endpoints = meta.device.endpoints.filter((e) => e.supportsInputCluster("boschEnergyDevice"));
                             for (const endpoint of endpoints) {
-                                await endpoint.write("boschSpecific", {
+                                await endpoint.write("boschEnergyDevice", {
                                     switchMode: 0x00,
                                     childLock: 0x00,
                                 });
-                                await endpoint.read("boschSpecific", ["switchMode", "childLock"]);
+                                await endpoint.read("boschEnergyDevice", ["switchMode", "childLock"]);
                             }
                         }
-                        await entity.write("boschSpecific", { switchType: selectedSwitchType });
-                        await entity.read("boschSpecific", ["switchType"]);
+                        await entity.write("boschEnergyDevice", {
+                            switchType: selectedSwitchType,
+                        });
+                        await entity.read("boschEnergyDevice", ["switchType"]);
                         return { state: { switch_type: value } };
                     }
                 },
                 convertGet: async (entity, key, meta) => {
                     if (key === "switch_type") {
-                        await entity.read("boschSpecific", ["switchType"]);
+                        await entity.read("boschEnergyDevice", ["switchType"]);
                     }
                 },
             },
@@ -611,7 +687,7 @@ exports.boschBmctExtend = {
         const configure = [
             async (device, coordinatorEndpoint, definition) => {
                 const endpoint = device.getEndpoint(1);
-                await endpoint.read("boschSpecific", ["switchType"]);
+                await endpoint.read("boschEnergyDevice", ["switchType"]);
             },
         ];
         return {
@@ -622,32 +698,6 @@ exports.boschBmctExtend = {
             isModernExtend: true,
         };
     },
-    handleZclVersionReadRequest: () => {
-        const onEvent = [
-            (event) => {
-                if (event.type !== "deviceAnnounce") {
-                    return;
-                }
-                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;
-                };
-            },
-        ];
-        return {
-            onEvent,
-            isModernExtend: true,
-        };
-    },
     reportSwitchAction: (args) => {
         const { switchTypeLookup, hasDualSwitchInputs } = args;
         const expose = (device, options) => {
@@ -655,7 +705,7 @@ exports.boschBmctExtend = {
             if (utils.isDummyDevice(device)) {
                 return exposeList;
             }
-            const switchTypeKey = device.getEndpoint(1).getClusterAttributeValue("boschSpecific", "switchType") ?? 0x00;
+            const switchTypeKey = device.getEndpoint(1).getClusterAttributeValue("boschEnergyDevice", "switchType") ?? 0x00;
             const selectedSwitchType = utils.getFromLookupByValue(switchTypeKey, switchTypeLookup);
             let supportedActionTypes;
             if (selectedSwitchType.includes("button")) {
@@ -687,7 +737,7 @@ exports.boschBmctExtend = {
         };
         const fromZigbee = [
             {
-                cluster: "boschSpecific",
+                cluster: "boschEnergyDevice",
                 type: ["raw"],
                 convert: (model, msg, publish, options, meta) => {
                     const command = msg.data[4];
@@ -764,7 +814,7 @@ exports.boschBmctExtend = {
             fz.power_on_behavior,
             fz.cover_position_tilt,
             {
-                cluster: "boschSpecific",
+                cluster: "boschEnergyDevice",
                 type: ["attributeReport", "readResponse"],
                 convert: (model, msg, publish, options, meta) => {
                     const result = {};
@@ -851,23 +901,23 @@ exports.boschBmctExtend = {
                     }
                     if (key === "device_mode") {
                         const index = utils.getFromLookup(value, stateDeviceMode);
-                        await entity.write("boschSpecific", { deviceMode: index });
-                        await entity.read("boschSpecific", ["deviceMode"]);
+                        await entity.write("boschEnergyDevice", { deviceMode: index });
+                        await entity.read("boschEnergyDevice", ["deviceMode"]);
                         return { state: { device_mode: value } };
                     }
                     if (key === "switch_type") {
                         const applyDefaultForSwitchModeAndChildLock = async (endpoint) => {
                             const switchModeDefault = utils.getFromLookup("coupled", stateSwitchMode);
                             const childLockDefault = utils.getFromLookup("OFF", stateOffOn);
-                            await endpoint.write("boschSpecific", {
+                            await endpoint.write("boschEnergyDevice", {
                                 switchMode: switchModeDefault,
                                 childLock: childLockDefault,
                             });
-                            await endpoint.read("boschSpecific", ["switchMode", "childLock"]);
+                            await endpoint.read("boschEnergyDevice", ["switchMode", "childLock"]);
                         };
                         const switchType = utils.getFromLookup(value, stateSwitchType);
-                        await entity.write("boschSpecific", { switchType: switchType });
-                        await entity.read("boschSpecific", ["switchType"]);
+                        await entity.write("boschEnergyDevice", { switchType: switchType });
+                        await entity.read("boschEnergyDevice", ["switchType"]);
                         await applyDefaultForSwitchModeAndChildLock(entity);
                         const leftEndpoint = meta.device.getEndpoint(2);
                         await applyDefaultForSwitchModeAndChildLock(leftEndpoint);
@@ -877,21 +927,21 @@ exports.boschBmctExtend = {
                     }
                     if (key === "switch_mode") {
                         const index = utils.getFromLookup(value, stateSwitchMode);
-                        await entity.write("boschSpecific", { switchMode: index });
+                        await entity.write("boschEnergyDevice", { switchMode: index });
                         return { state: { switch_mode: value } };
                     }
                     if (key === "child_lock") {
                         const index = utils.getFromLookup(value, stateOffOn);
-                        await entity.write("boschSpecific", { childLock: index });
+                        await entity.write("boschEnergyDevice", { childLock: index });
                         return { state: { child_lock: value } };
                     }
                     if (key === "auto_off_enabled") {
                         const index = utils.getFromLookup(value, stateOffOn);
-                        await entity.write("boschSpecific", { autoOffEnabled: index });
+                        await entity.write("boschEnergyDevice", { autoOffEnabled: index });
                         return { state: { auto_off_enabled: value } };
                     }
                     if (key === "auto_off_time" && typeof value === "number") {
-                        await entity.write("boschSpecific", { autoOffTime: value * 60 });
+                        await entity.write("boschEnergyDevice", { autoOffTime: value * 60 });
                         return { state: { auto_off_time: value } };
                     }
                 },
@@ -905,22 +955,22 @@ exports.boschBmctExtend = {
                             }
                             break;
                         case "device_mode":
-                            await entity.read("boschSpecific", ["deviceMode"]);
+                            await entity.read("boschEnergyDevice", ["deviceMode"]);
                             break;
                         case "switch_type":
-                            await entity.read("boschSpecific", ["switchType"]);
+                            await entity.read("boschEnergyDevice", ["switchType"]);
                             break;
                         case "switch_mode":
-                            await entity.read("boschSpecific", ["switchMode"]);
+                            await entity.read("boschEnergyDevice", ["switchMode"]);
                             break;
                         case "child_lock":
-                            await entity.read("boschSpecific", ["childLock"]);
+                            await entity.read("boschEnergyDevice", ["childLock"]);
                             break;
                         case "auto_off_enabled":
-                            await entity.read("boschSpecific", ["autoOffEnabled"]);
+                            await entity.read("boschEnergyDevice", ["autoOffEnabled"]);
                             break;
                         case "auto_off_time":
-                            await entity.read("boschSpecific", ["autoOffTime"]);
+                            await entity.read("boschEnergyDevice", ["autoOffTime"]);
                             break;
                         default:
                             throw new Error(`Unhandled key boschExtend.bmct.toZigbee.convertGet ${key}`);
@@ -933,41 +983,45 @@ exports.boschBmctExtend = {
                     if (key === "calibration_opening_time") {
                         const number = utils.toNumber(value, "calibration_opening_time");
                         const index = number * 10;
-                        await entity.write("boschSpecific", { calibrationOpeningTime: index });
+                        await entity.write("boschEnergyDevice", { calibrationOpeningTime: index });
                         return { state: { calibration_opening_time: number } };
                     }
                     if (key === "calibration_closing_time") {
                         const number = utils.toNumber(value, "calibration_closing_time");
                         const index = number * 10;
-                        await entity.write("boschSpecific", { calibrationClosingTime: index });
+                        await entity.write("boschEnergyDevice", { calibrationClosingTime: index });
                         return { state: { calibration_closing_time: number } };
                     }
                     if (key === "calibration_button_hold_time") {
                         const number = utils.toNumber(value, "calibration_button_hold_time");
                         const index = number * 10;
-                        await entity.write("boschSpecific", { calibrationButtonHoldTime: index });
+                        await entity.write("boschEnergyDevice", {
+                            calibrationButtonHoldTime: index,
+                        });
                         return { state: { calibration_button_hold_time: number } };
                     }
                     if (key === "calibration_motor_start_delay") {
                         const number = utils.toNumber(value, "calibration_motor_start_delay");
                         const index = number * 10;
-                        await entity.write("boschSpecific", { calibrationMotorStartDelay: index });
+                        await entity.write("boschEnergyDevice", {
+                            calibrationMotorStartDelay: index,
+                        });
                         return { state: { calibration_motor_start_delay: number } };
                     }
                 },
                 convertGet: async (entity, key, meta) => {
                     switch (key) {
                         case "calibration_opening_time":
-                            await entity.read("boschSpecific", ["calibrationOpeningTime"]);
+                            await entity.read("boschEnergyDevice", ["calibrationOpeningTime"]);
                             break;
                         case "calibration_closing_time":
-                            await entity.read("boschSpecific", ["calibrationClosingTime"]);
+                            await entity.read("boschEnergyDevice", ["calibrationClosingTime"]);
                             break;
                         case "calibration_button_hold_time":
-                            await entity.read("boschSpecific", ["calibrationButtonHoldTime"]);
+                            await entity.read("boschEnergyDevice", ["calibrationButtonHoldTime"]);
                             break;
                         case "calibration_motor_start_delay":
-                            await entity.read("boschSpecific", ["calibrationMotorStartDelay"]);
+                            await entity.read("boschEnergyDevice", ["calibrationMotorStartDelay"]);
                             break;
                         default:
                             throw new Error(`Unhandled key boschExtend.bmct.toZigbee.convertGet ${key}`);
@@ -1295,6 +1349,298 @@ exports.boschBsirExtend = {
         return { exposes, fromZigbee, configure, isModernExtend: true };
     },
 };
+exports.boschDoorWindowContactExtend = {
+    doorWindowContactCluster: () => m.deviceAddCustomCluster("boschDoorWindowContactCluster", {
+        ID: 0xfcad,
+        attributes: {
+            breakFunctionEnabled: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            breakFunctionState: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            breakFunctionTimeout: { ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            vibrationDetectionEnabled: { ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            vibrationDetectionSensitivity: { ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            unknownOne: { ID: 0x0007, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            unknownTwo: { ID: 0x0008, type: zigbee_herdsman_1.Zcl.DataType.UINT16, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            unknownThree: { ID: 0x0009, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+            unknownFour: { ID: 0x000a, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: exports.manufacturerOptions.manufacturerCode },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    battery: () => m.battery({
+        percentage: true,
+        lowStatus: true,
+        lowStatusReportingConfig: { min: "MIN", max: "MAX", change: 0 },
+    }),
+    reportContactState: () => m.iasZoneAlarm({
+        zoneType: "contact",
+        zoneAttributes: ["alarm_1"],
+        description: "Indicates whether the device detected an open or closed door/window",
+    }),
+    reportButtonActions: (args) => {
+        const { doublePressSupported } = args ?? { doublePressSupported: false };
+        let buttonActionsLookup = {
+            long_press: 0x02,
+            single_press: 0x01,
+            none: 0x00,
+        };
+        if (doublePressSupported) {
+            buttonActionsLookup = { ...{ double_press: 0x08 }, ...buttonActionsLookup };
+        }
+        const exposes = [
+            e
+                .enum("action", ea.STATE, Object.keys(buttonActionsLookup))
+                .withDescription("Indicates button presses on the device")
+                .withCategory("diagnostic"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "ssIasZone",
+                type: ["commandStatusChangeNotification", "attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const zoneStatus = "zonestatus" in msg.data ? msg.data.zonestatus : msg.data.zoneStatus;
+                    if (zoneStatus !== undefined) {
+                        const buttonPayload = zoneStatus >> 11;
+                        const buttonState = utils.getFromLookupByValue(buttonPayload, buttonActionsLookup);
+                        const result = {
+                            action: buttonState,
+                        };
+                        return result;
+                    }
+                },
+            },
+        ];
+        const configure = [m.setupConfigureForBinding("ssIasZone", "input"), m.setupConfigureForReading("ssIasZone", ["zoneStatus"])];
+        return {
+            exposes,
+            fromZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    breakFunctionality: () => {
+        const breakFunctionEnabledLookup = {
+            ON: 0x01,
+            OFF: 0x00,
+        };
+        const breakFunctionStatusLookup = {
+            break_active: 0x01,
+            idle: 0x00,
+        };
+        const exposes = [
+            e
+                .binary("break_function_enabled", ea.ALL, utils.getFromLookupByValue(0x01, breakFunctionEnabledLookup), utils.getFromLookupByValue(0x00, breakFunctionEnabledLookup))
+                .withLabel("Break function")
+                .withDescription("Activate the break function by pressing the operating button on the door/window contact twice. This means that the device temporarily stops reading the sensors.")
+                .withCategory("config"),
+            e
+                .numeric("break_function_timeout", ea.ALL)
+                .withLabel("Automatic time limit for breaks")
+                .withDescription("Here you can define how long the break function is activated for the door/window contact. Once the time limit has expired, the break ends automatically. The LED on the device will flash orange as long as the break is activated when this setting is being used.")
+                .withValueMin(1)
+                .withValueMax(15)
+                .withUnit("minutes")
+                .withPreset("disable", null, "Disable automatic time limit")
+                .withCategory("config"),
+            e
+                .enum("break_function_state", ea.STATE_GET, Object.keys(breakFunctionStatusLookup))
+                .withLabel("Break function state")
+                .withDescription("Indicates whether the device is in break mode or not"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "boschDoorWindowContactCluster",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.breakFunctionEnabled !== undefined) {
+                        result.break_function_enabled = utils.getFromLookupByValue(data.breakFunctionEnabled, breakFunctionEnabledLookup);
+                    }
+                    if (data.breakFunctionTimeout !== undefined) {
+                        result.break_function_timeout = data.breakFunctionTimeout === 0xff ? null : data.breakFunctionTimeout;
+                    }
+                    if (data.breakFunctionState !== undefined) {
+                        result.break_function_state = utils.getFromLookupByValue(data.breakFunctionState, breakFunctionStatusLookup);
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["break_function_enabled", "break_function_timeout", "break_function_state"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (key === "break_function_enabled") {
+                        await entity.write("boschDoorWindowContactCluster", {
+                            breakFunctionEnabled: utils.getFromLookup(value, breakFunctionEnabledLookup),
+                        });
+                        return { state: { break_function_enabled: value } };
+                    }
+                    if (key === "break_function_timeout") {
+                        const index = value === null ? 0xff : utils.toNumber(value);
+                        await entity.write("boschDoorWindowContactCluster", {
+                            breakFunctionTimeout: index,
+                        });
+                        return { state: { break_function_timeout: value } };
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    if (key === "break_function_enabled") {
+                        await entity.read("boschDoorWindowContactCluster", [
+                            "breakFunctionEnabled",
+                        ]);
+                    }
+                    if (key === "break_function_timeout") {
+                        await entity.read("boschDoorWindowContactCluster", [
+                            "breakFunctionTimeout",
+                        ]);
+                    }
+                    if (key === "break_function_state") {
+                        await entity.read("boschDoorWindowContactCluster", [
+                            "breakFunctionState",
+                        ]);
+                    }
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForReading("boschDoorWindowContactCluster", [
+                "breakFunctionEnabled",
+                "breakFunctionTimeout",
+                "breakFunctionState",
+            ]),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    vibrationDetection: () => {
+        const vibrationDetectionEnabledLookup = {
+            ON: 0x01,
+            OFF: 0x00,
+        };
+        const vibrationDetectionSensitivityLookup = {
+            very_high: 0x05,
+            high: 0x04,
+            medium: 0x03,
+            moderate: 0x02,
+            low: 0x01,
+        };
+        const exposes = [
+            e
+                .binary("vibration_detection_enabled", ea.ALL, utils.getFromLookupByValue(0x01, vibrationDetectionEnabledLookup), utils.getFromLookupByValue(0x00, vibrationDetectionEnabledLookup))
+                .withLabel("Vibration detection")
+                .withDescription("Activate the vibration detection to detect vibrations at the window or door via the integrated sensor as well")
+                .withCategory("config"),
+            e
+                .enum("vibration_detection_sensitivity", ea.ALL, Object.keys(vibrationDetectionSensitivityLookup))
+                .withLabel("Vibration detection sensitivity")
+                .withDescription("Set the sensitivity of the vibration detection sensor")
+                .withCategory("config"),
+            e.binary("vibration", ea.STATE_GET, true, false).withDescription("Indicates whether the device detected vibration"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "boschDoorWindowContactCluster",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.vibrationDetectionEnabled !== undefined) {
+                        result.vibration_detection_enabled = utils.getFromLookupByValue(data.vibrationDetectionEnabled, vibrationDetectionEnabledLookup);
+                    }
+                    if (data.vibrationDetectionSensitivity !== undefined) {
+                        result.vibration_detection_sensitivity = utils.getFromLookupByValue(data.vibrationDetectionSensitivity, vibrationDetectionSensitivityLookup);
+                    }
+                    return result;
+                },
+            },
+            {
+                cluster: "ssIasZone",
+                type: ["commandStatusChangeNotification", "attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const zoneStatus = "zonestatus" in msg.data ? msg.data.zonestatus : msg.data.zoneStatus;
+                    if (zoneStatus !== undefined) {
+                        const alarm2Payload = (zoneStatus & (1 << 1)) > 0;
+                        return {
+                            vibration: alarm2Payload,
+                        };
+                    }
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["vibration_detection_enabled", "vibration_detection_sensitivity", "vibration"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (key === "vibration_detection_enabled") {
+                        await entity.write("boschDoorWindowContactCluster", {
+                            vibrationDetectionEnabled: utils.getFromLookup(value, vibrationDetectionEnabledLookup),
+                        });
+                        return { state: { vibration_detection_enabled: value } };
+                    }
+                    if (key === "vibration_detection_sensitivity") {
+                        await entity.write("boschDoorWindowContactCluster", {
+                            vibrationDetectionSensitivity: utils.getFromLookup(value, vibrationDetectionSensitivityLookup),
+                        });
+                        return { state: { vibration_detection_sensitivity: value } };
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    if (key === "vibration_detection_enabled") {
+                        await entity.read("boschDoorWindowContactCluster", [
+                            "vibrationDetectionEnabled",
+                        ]);
+                    }
+                    if (key === "vibration_detection_sensitivity") {
+                        await entity.read("boschDoorWindowContactCluster", [
+                            "vibrationDetectionSensitivity",
+                        ]);
+                    }
+                    if (key === "vibration") {
+                        await entity.read("ssIasZone", ["zoneStatus"]);
+                    }
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForBinding("ssIasZone", "input"),
+            m.setupConfigureForReading("ssIasZone", ["zoneStatus"]),
+            async (device, coordinatorEndpoint, definition) => {
+                const endpoint = device.getEndpoint(1);
+                // The write request is made when using the proprietary
+                // Bosch Smart Home Controller II as of 19-09-2025. Looks like
+                // the default value was too high, and they didn't want to
+                // push a firmware update. We mimic it here to avoid complaints.
+                await endpoint.write("boschDoorWindowContactCluster", {
+                    vibrationDetectionSensitivity: vibrationDetectionSensitivityLookup.medium,
+                });
+                // The write request is made when using the proprietary
+                // Bosch Smart Home Controller II as of 19-09-2025. I have
+                // no idea what it does, but we mimic it here in case it
+                // fixes any issues.
+                await endpoint.write("boschDoorWindowContactCluster", {
+                    unknownOne: 0x00,
+                });
+            },
+            m.setupConfigureForReading("boschDoorWindowContactCluster", [
+                "vibrationDetectionEnabled",
+                "vibrationDetectionSensitivity",
+            ]),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+};
 exports.boschBsenExtend = {
     customIasZoneCluster: () => m.deviceAddCustomCluster("ssIasZone", {
         ID: zigbee_herdsman_1.Zcl.Clusters.ssIasZone.ID,
@@ -1532,5 +1878,143 @@ exports.boschBsenExtend = {
         };
     },
 };
+exports.boschSmartPlugExtend = {
+    smartPlugCluster: () => m.deviceAddCustomCluster("boschEnergyDevice", {
+        ID: 0xfca0,
+        manufacturerCode: exports.manufacturerOptions.manufacturerCode,
+        attributes: {
+            autoOffEnabled: { ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+            autoOffTime: { ID: 0x0007, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+            ledBrightness: { ID: 0x002c, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+            energySavingModeEnabled: { ID: 0x002d, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+            energySavingModeThreshold: { ID: 0x002e, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+            energySavingModeTimer: { ID: 0x002f, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    onOff: () => m.onOff({ powerOnBehavior: true, configureReporting: true }),
+    ledBrightness: () => m.numeric({
+        name: "led_brightness",
+        cluster: "boschEnergyDevice",
+        attribute: "ledBrightness",
+        label: "LED brightness",
+        description: "Here you can adjust the LED brightness",
+        valueMin: 0,
+        valueMax: 100,
+        valueStep: 1,
+        unit: "%",
+        entityCategory: "config",
+    }),
+    energySavingMode: () => {
+        const energySavingModeEnabledLookup = {
+            ON: 0x01,
+            OFF: 0x00,
+        };
+        const exposes = [
+            e
+                .binary("energy_saving_mode_enabled", ea.ALL, utils.getFromLookupByValue(0x01, energySavingModeEnabledLookup), utils.getFromLookupByValue(0x00, energySavingModeEnabledLookup))
+                .withLabel("Enable energy-saving mode")
+                .withDescription("Here you can enable/disable the energy-saving mode")
+                .withCategory("config"),
+            e
+                .numeric("energy_saving_mode_threshold", ea.ALL)
+                .withLabel("Energy-saving threshold")
+                .withDescription("Here you can set the threshold for the energy-saving mode. If the consumption falls below the set value (and the timer has been met), the smart plug will be turned off.")
+                .withUnit("watt")
+                .withValueMin(1)
+                .withValueMax(50)
+                .withValueStep(1)
+                .withCategory("config"),
+            e
+                .numeric("energy_saving_mode_timer", ea.ALL)
+                .withLabel("Energy-saving timer")
+                .withDescription("Here you can set the time the threshold has to be met before the smart plug is turned off")
+                .withUnit("seconds")
+                .withValueMin(1)
+                .withValueMax(1800)
+                .withValueStep(1)
+                .withCategory("config"),
+        ];
+        const fromZigbee = [
+            {
+                cluster: "boschEnergyDevice",
+                type: ["attributeReport", "readResponse"],
+                convert: (model, msg, publish, options, meta) => {
+                    const result = {};
+                    const data = msg.data;
+                    if (data.energySavingModeEnabled !== undefined) {
+                        result.energy_saving_mode_enabled = utils.getFromLookupByValue(data.energySavingModeEnabled, energySavingModeEnabledLookup);
+                    }
+                    if (data.energySavingModeThreshold !== undefined) {
+                        result.energy_saving_mode_threshold = utils.toNumber(data.energySavingModeThreshold) / 10;
+                    }
+                    if (data.energySavingModeTimer !== undefined) {
+                        result.energy_saving_mode_timer = utils.toNumber(data.energySavingModeTimer);
+                    }
+                    return result;
+                },
+            },
+        ];
+        const toZigbee = [
+            {
+                key: ["energy_saving_mode_enabled", "energy_saving_mode_threshold", "energy_saving_mode_timer"],
+                convertSet: async (entity, key, value, meta) => {
+                    if (key === "energy_saving_mode_enabled") {
+                        await entity.write("boschEnergyDevice", {
+                            energySavingModeEnabled: utils.getFromLookup(value, energySavingModeEnabledLookup),
+                        });
+                        return { state: { energy_saving_mode_enabled: value } };
+                    }
+                    if (key === "energy_saving_mode_threshold") {
+                        await entity.write("boschEnergyDevice", {
+                            energySavingModeThreshold: utils.toNumber(value) * 10,
+                        });
+                        return { state: { energy_saving_mode_threshold: value } };
+                    }
+                    if (key === "energy_saving_mode_timer") {
+                        await entity.write("boschEnergyDevice", {
+                            energySavingModeTimer: utils.toNumber(value),
+                        });
+                        return { state: { energy_saving_mode_timer: value } };
+                    }
+                },
+                convertGet: async (entity, key, meta) => {
+                    if (key === "energy_saving_mode_enabled") {
+                        await entity.read("boschEnergyDevice", ["energySavingModeEnabled"]);
+                    }
+                    if (key === "energy_saving_mode_threshold") {
+                        await entity.read("boschEnergyDevice", ["energySavingModeThreshold"]);
+                    }
+                    if (key === "energy_saving_mode_timer") {
+                        await entity.read("boschEnergyDevice", ["energySavingModeTimer"]);
+                    }
+                },
+            },
+        ];
+        const configure = [
+            m.setupConfigureForBinding("boschEnergyDevice", "input"),
+            m.setupConfigureForReading("boschEnergyDevice", [
+                "energySavingModeEnabled",
+                "energySavingModeThreshold",
+                "energySavingModeTimer",
+            ]),
+        ];
+        return {
+            exposes,
+            fromZigbee,
+            toZigbee,
+            configure,
+            isModernExtend: true,
+        };
+    },
+    electricityMeter: (args) => m.electricityMeter({
+        voltage: false,
+        current: false,
+        power: { change: 1 },
+        energy: { change: 1 },
+        ...args,
+    }),
+};
 //endregion
 //# sourceMappingURL=bosch.js.map