@willieee802/zigbee-herdsman-converters 19.44.4 → 19.45.0

package/dist/devices/shelly.js

@@ -265,9 +265,10 @@ const shellyModernExtend = {
         // Shelly Gen4 devices report haElectricalMeasurement.powerFactor (0x0510) as INT16 (0x29)
         // while zigbee-herdsman defines it as INT8 (0x28). This breaks configureReporting (INVALID_DATA_TYPE).
         return m.deviceAddCustomCluster("haElectricalMeasurement", {
+            name: "haElectricalMeasurement",
             ID: HA_ELECTRICAL_MEASUREMENT_CLUSTER_ID,
             attributes: {
-                powerFactor: { ID: HA_ELECTRICAL_MEASUREMENT_POWER_FACTOR_ATTR_ID, type: zigbee_herdsman_1.Zcl.DataType.INT16 },
+                powerFactor: { name: "powerFactor", ID: HA_ELECTRICAL_MEASUREMENT_POWER_FACTOR_ATTR_ID, type: zigbee_herdsman_1.Zcl.DataType.INT16 },
             },
             commands: {},
             commandsResponse: {},
@@ -276,31 +277,33 @@ const shellyModernExtend = {
     shellyCustomClusters() {
         return [
             m.deviceAddCustomCluster("shellyRPCCluster", {
+                name: "shellyRPCCluster",
                 ID: 0xfc01,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SHELLY,
                 attributes: {
-                    data: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-                    txCtl: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
-                    rxCtl: { ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
+                    data: { name: "data", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    txCtl: { name: "txCtl", ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
+                    rxCtl: { name: "rxCtl", ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
                 },
                 commands: {},
                 commandsResponse: {},
             }),
             m.deviceAddCustomCluster("shellyWiFiSetupCluster", {
+                name: "shellyWiFiSetupCluster",
                 ID: 0xfc02,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SHELLY,
                 attributes: {
-                    status: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-                    ip: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-                    actionCode: { ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-                    dhcp: { ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
-                    enabled: { ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
-                    ssid: { ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-                    password: { ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-                    staticIp: { ID: 0x0007, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-                    netMask: { ID: 0x0008, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-                    gateway: { ID: 0x0009, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-                    nameServer: { ID: 0x000a, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    status: { name: "status", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    ip: { name: "ip", ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    actionCode: { name: "actionCode", ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+                    dhcp: { name: "dhcp", ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+                    enabled: { name: "enabled", ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+                    ssid: { name: "ssid", ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    password: { name: "password", ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    staticIp: { name: "staticIp", ID: 0x0007, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    netMask: { name: "netMask", ID: 0x0008, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    gateway: { name: "gateway", ID: 0x0009, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+                    nameServer: { name: "nameServer", ID: 0x000a, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
                 },
                 commands: {},
                 commandsResponse: {},
@@ -312,6 +315,9 @@ const shellyModernExtend = {
         const shellyRPCBugFixed = false; // For firmware 20250819-150402/ga0def2d
         const featureDev = features.includes("Dev");
         const featurePowerstripUI = features.includes("PowerstripUI");
+        const featurePowerstripPowerOnBehavior = features.includes("PowerstripPowerOnBehavior");
+        const featureTwoPMInputMode = features.includes("2PMInputMode");
+        const featureOnePMInputMode = features.includes("1PMInputMode");
         // Generic helper functions
         const validateTime = (value) => {
             const hhmmRegex = /^([01][0-9]|2[0-3]):[0-5][0-9]$/;
@@ -433,13 +439,27 @@ const shellyModernExtend = {
                         state.rpc_rxctl = msg.data.rxCtl;
                         state.rpc_data = "";
                     }
-                    if (msg.data.data !== undefined)
-                        state.rpc_data = meta.state.rpc_data + msg.data.data;
+                    if (msg.data.data !== undefined) {
+                        const accumulated = (meta.state.rpc_data ?? "") + msg.data.data;
+                        state.rpc_data = accumulated;
+                        const expectedLen = meta.state.rpc_rxctl;
+                        if (expectedLen > 0 && accumulated.length >= expectedLen) {
+                            try {
+                                const response = JSON.parse(accumulated);
+                                if (response.result?.in_mode !== undefined) {
+                                    const epName = response.result.id === 0 ? "sw1" : "sw2";
+                                    state[`switch_mode_${epName}`] = response.result.in_mode;
+                                }
+                            }
+                            catch { }
+                        }
+                    }
                     return state;
                 },
             },
         ];
         const toZigbee = [];
+        const configure = [];
         const toZigbeeDev = [
             {
                 key: ["rpc_rxctl", "rpc_data"],
@@ -574,7 +594,108 @@ const shellyModernExtend = {
             exposes.push(...exposesPowerstripUI);
             toZigbee.push(...toZigbeePowerstripUI);
         }
-        return { exposes, fromZigbee, toZigbee, isModernExtend: true };
+        if (featurePowerstripPowerOnBehavior) {
+            const powerOnBehaviorValues = ["off", "on", "previous", "match_input"];
+            for (const channel of [1, 2, 3, 4]) {
+                exposes.push(e
+                    .enum("power_on_behavior", ea.STATE_SET, powerOnBehaviorValues)
+                    .withDescription("Behavior of the socket after a power outage. 'previous' restores the last known state.")
+                    .withCategory("config")
+                    .withEndpoint(String(channel)));
+            }
+            toZigbee.push({
+                key: ["power_on_behavior"],
+                convertSet: async (entity, key, value, meta) => {
+                    utils.assertString(value, key);
+                    utils.assertString(meta.endpoint_name, "endpoint_name");
+                    utils.assertEndpoint(entity);
+                    const switchId = Number(meta.endpoint_name) - 1;
+                    // shellyRPCCluster lives on a dedicated endpoint (239), but this expose is per-channel.
+                    // determineEndpoint() would return the per-channel endpoint when endpoint_name is set,
+                    // so we explicitly resolve the RPC endpoint via the device.
+                    const ep = entity.getDevice().getEndpoint(SHELLY_ENDPOINT_ID);
+                    if (!ep)
+                        throw new Error(`Shelly RPC endpoint ${SHELLY_ENDPOINT_ID} not found`);
+                    const shellyValue = value === "previous" ? "restore_last" : value;
+                    await rpcSend(ep, "Switch.SetConfig", { id: switchId, config: { initial_state: shellyValue } });
+                    return { state: { power_on_behavior: value } };
+                },
+            });
+        }
+        if (featureTwoPMInputMode) {
+            const inModeValues = ["follow", "flip", "detached", "cycle", "activation"];
+            exposes.push((device, _options) => {
+                if (utils.isDummyDevice(device) || !device.getEndpoint(SHELLY_ENDPOINT_ID))
+                    return [];
+                return [
+                    e.enum("switch_mode", ea.ALL, inModeValues).withDescription("Switch input mode").withCategory("config").withEndpoint("sw1"),
+                    e.enum("switch_mode", ea.ALL, inModeValues).withDescription("Switch input mode").withCategory("config").withEndpoint("sw2"),
+                ];
+            });
+            toZigbee.push({
+                key: ["switch_mode"],
+                convertSet: async (entity, key, value, meta) => {
+                    const switchId = meta.endpoint_name === "sw1" ? 0 : 1;
+                    const ep = (0, utils_1.determineEndpoint)(entity, meta, "shellyRPCCluster");
+                    await rpcSend(ep, "Switch.SetConfig", { id: switchId, config: { in_mode: value } });
+                    return { state: { switch_mode: value } };
+                },
+                convertGet: async (entity, key, meta) => {
+                    const switchId = meta.endpoint_name === "sw1" ? 0 : 1;
+                    const ep = (0, utils_1.determineEndpoint)(entity, meta, "shellyRPCCluster");
+                    await rpcSend(ep, "Switch.GetConfig", { id: switchId });
+                    await rpcReceive(ep, "rpc_rxctl");
+                },
+            });
+            configure.push(async (device) => {
+                const ep = device.getEndpoint(SHELLY_ENDPOINT_ID);
+                if (!ep)
+                    return;
+                try {
+                    for (const id of [0, 1]) {
+                        await rpcSend(ep, "Switch.GetConfig", { id });
+                        await rpcReceive(ep, "rpc_rxctl");
+                    }
+                }
+                catch (e) {
+                    logger_1.logger.warning(`Failed to read switch_mode during configure, use get to retry: ${e}`, NS);
+                }
+            });
+        }
+        if (featureOnePMInputMode) {
+            const inModeValues = ["follow", "flip", "detached", "cycle", "activation"];
+            exposes.push((device, _options) => {
+                if (utils.isDummyDevice(device) || !device.getEndpoint(SHELLY_ENDPOINT_ID))
+                    return [];
+                return [e.enum("switch_mode", ea.ALL, inModeValues).withDescription("Switch input mode").withCategory("config").withEndpoint("sw1")];
+            });
+            toZigbee.push({
+                key: ["switch_mode"],
+                convertSet: async (entity, key, value, meta) => {
+                    const ep = (0, utils_1.determineEndpoint)(entity, meta, "shellyRPCCluster");
+                    await rpcSend(ep, "Switch.SetConfig", { id: 0, config: { in_mode: value } });
+                    return { state: { switch_mode: value } };
+                },
+                convertGet: async (entity, key, meta) => {
+                    const ep = (0, utils_1.determineEndpoint)(entity, meta, "shellyRPCCluster");
+                    await rpcSend(ep, "Switch.GetConfig", { id: 0 });
+                    await rpcReceive(ep, "rpc_rxctl");
+                },
+            });
+            configure.push(async (device) => {
+                const ep = device.getEndpoint(SHELLY_ENDPOINT_ID);
+                if (!ep)
+                    return;
+                try {
+                    await rpcSend(ep, "Switch.GetConfig", { id: 0 });
+                    await rpcReceive(ep, "rpc_rxctl");
+                }
+                catch (e) {
+                    logger_1.logger.warning(`Failed to read switch_mode during configure, use get to retry: ${e}`, NS);
+                }
+            });
+        }
+        return { exposes, fromZigbee, toZigbee, configure, isModernExtend: true };
     },
     shellyWiFiSetup() {
         // biome-ignore lint/suspicious/noExplicitAny: generic
@@ -826,10 +947,61 @@ const shellyModernExtend = {
         ];
         return { exposes, fromZigbee, isModernExtend: true };
     },
+    shellyLightLevel(args) {
+        const reporting = args?.reporting ?? { min: "1_MINUTE", max: 900, change: 0 };
+        return [
+            m.deviceAddCustomCluster("shellyLightLevel", {
+                name: "shellyLightLevel",
+                ID: 0xfc21,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SHELLY,
+                attributes: {
+                    lightLevel: { name: "lightLevel", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    darkThreshold: { name: "darkThreshold", ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT24, write: true },
+                    brightThreshold: { name: "brightThreshold", ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT24, write: true },
+                },
+                commands: {},
+                commandsResponse: {},
+            }),
+            m.enumLookup({
+                name: "light_level",
+                cluster: "shellyLightLevel",
+                attribute: "lightLevel",
+                lookup: { dark: 0, twilight: 1, bright: 2 },
+                description: "Coarse light level",
+                reporting,
+                access: "STATE_GET",
+            }),
+            m.numeric({
+                name: "dark_threshold",
+                cluster: "shellyLightLevel",
+                attribute: "darkThreshold",
+                valueMin: 0,
+                valueMax: 65535,
+                reporting: false,
+                description: "Lux threshold below which light level is dark",
+                unit: "lx",
+                access: "ALL",
+            }),
+            m.numeric({
+                name: "bright_threshold",
+                cluster: "shellyLightLevel",
+                attribute: "brightThreshold",
+                valueMin: 0,
+                valueMax: 65535,
+                reporting: false,
+                description: "Lux threshold above which light level is bright",
+                unit: "lx",
+                access: "ALL",
+            }),
+        ];
+    },
 };
 // =============================================================================
 // Local From Zigbee Converters
 // =============================================================================
+const handlePosition = e
+    .enum("handle_position", ea.STATE, ["closed", "tilted", "open"])
+    .withDescription("Handle position: closed, tilted (partly open), or open");
 const fzLocal = {
     one_button_events: {
         cluster: "genOnOff",
@@ -839,15 +1011,27 @@ const fzLocal = {
             return { action: event };
         },
     },
+    one_button_scene_events: {
+        cluster: "genScenes",
+        type: ["commandRecall"],
+        convert: (model, msg, publish, options, meta) => {
+            const event = utils.getFromLookup(`${msg.endpoint.ID}`, { "1": "single_long", "2": "double_long", "3": "triple_long" });
+            return { action: event };
+        },
+    },
     four_buttons_single_events: {
         cluster: "genOnOff",
-        type: ["commandOn", "commandOff"],
+        type: ["commandOn", "commandOff", "commandToggle"],
         convert: (model, msg, publish, options, meta) => {
             const event = utils.getFromLookup(`${msg.endpoint.ID}_${msg.type}`, {
                 "1_commandOn": "1_single",
                 "1_commandOff": "2_single",
                 "2_commandOn": "3_single",
                 "2_commandOff": "4_single",
+                "1_commandToggle": "1_single",
+                "2_commandToggle": "2_single",
+                "3_commandToggle": "3_single",
+                "4_commandToggle": "4_single",
             });
             return { action: event };
         },
@@ -865,6 +1049,141 @@ const fzLocal = {
             return { action: event };
         },
     },
+    four_buttons_scene_events: {
+        cluster: "genScenes",
+        type: ["commandRecall"],
+        convert: (model, msg, publish, options, meta) => {
+            const event = utils.getFromLookup(`${msg.endpoint.ID}_${msg.data.sceneid}`, {
+                "1_1": "1_double",
+                "2_1": "2_double",
+                "3_1": "3_double",
+                "4_1": "4_double",
+                "1_2": "1_triple",
+                "2_2": "2_triple",
+                "3_2": "3_triple",
+                "4_2": "4_triple",
+                "1_11": "1_single_long",
+                "2_11": "2_single_long",
+                "3_11": "3_single_long",
+                "4_11": "4_single_long",
+                "1_12": "1_double_long",
+                "2_12": "2_double_long",
+                "3_12": "3_double_long",
+                "4_12": "4_double_long",
+                "1_13": "1_triple_long",
+                "2_13": "2_triple_long",
+                "3_13": "3_triple_long",
+                "4_13": "4_triple_long",
+            });
+            return { action: event };
+        },
+    },
+    two_switch_inputs_events: {
+        cluster: "genOnOff",
+        type: ["commandOn", "commandOff", "commandToggle"],
+        convert: (model, msg, publish, options, meta) => {
+            const event = utils.getFromLookup(`${msg.endpoint.ID}_${msg.type}`, {
+                "3_commandOn": "input_1_on",
+                "3_commandOff": "input_1_off",
+                "3_commandToggle": "input_1_toggle",
+                "4_commandOn": "input_2_on",
+                "4_commandOff": "input_2_off",
+                "4_commandToggle": "input_2_toggle",
+            });
+            return { action: event };
+        },
+    },
+    two_switch_inputs_scene_events: {
+        cluster: "genScenes",
+        type: ["commandRecall"],
+        convert: (model, msg, publish, options, meta) => {
+            const event = utils.getFromLookup(`${msg.endpoint.ID}_${msg.data.sceneid}`, {
+                "3_5": "input_1_toggle",
+                "4_5": "input_2_toggle",
+                "3_11": "input_1_hold",
+                "4_11": "input_2_hold",
+            });
+            return { action: event };
+        },
+    },
+    one_switch_input_events: {
+        cluster: "genOnOff",
+        type: ["commandOn", "commandOff", "commandToggle"],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.endpoint.ID !== 2)
+                return {};
+            const event = utils.getFromLookup(msg.type, {
+                commandOn: "input_1_on",
+                commandOff: "input_1_off",
+                commandToggle: "input_1_toggle",
+            });
+            return { action: event };
+        },
+    },
+    one_switch_input_scene_events: {
+        cluster: "genScenes",
+        type: ["commandRecall"],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.endpoint.ID !== 2)
+                return {};
+            const event = utils.getFromLookup(`${msg.data.sceneid}`, { "5": "input_1_toggle", "11": "input_1_hold" });
+            return { action: event };
+        },
+    },
+    switch_input_type: {
+        cluster: "genOnOffSwitchCfg",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            if (!Object.hasOwn(msg.data, "switchType"))
+                return {};
+            const epName = utils.getFromLookup(msg.endpoint.ID, { 2: "sw1", 3: "sw1", 4: "sw2" });
+            if (!epName)
+                return {};
+            return { [`switch_type_${epName}`]: utils.getFromLookup(msg.data.switchType, { 0: "toggle", 1: "momentary" }) };
+        },
+    },
+    blu_door_window: {
+        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)
+                return;
+            const alarm1 = (zoneStatus & 1) > 0;
+            const alarm2 = (zoneStatus & (1 << 1)) > 0;
+            // Zone type 0x0016 (door/window handle) per ZigBee spec Table 8-7:
+            //   alarm1=0, alarm2=0 -> closed
+            //   alarm1=1, alarm2=0 -> tilted (partly open)
+            //   alarm1=1, alarm2=1 -> open
+            let position;
+            if (!alarm1 && !alarm2)
+                position = "closed";
+            else if (alarm1 && !alarm2)
+                position = "tilted";
+            else
+                position = "open";
+            return {
+                contact: position === "closed",
+                handle_position: position,
+                battery_low: (zoneStatus & (1 << 3)) > 0,
+            };
+        },
+    },
+};
+const tzLocal = {
+    switch_input_type: {
+        key: ["switch_type"],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = { toggle: 0, momentary: 1 };
+            const ep = (0, utils_1.determineEndpoint)(entity, meta, "genOnOffSwitchCfg");
+            await ep.write("genOnOffSwitchCfg", { switchType: utils.getFromLookup(value, lookup) });
+            return { state: { switch_type: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            const ep = (0, utils_1.determineEndpoint)(entity, meta, "genOnOffSwitchCfg");
+            await ep.read("genOnOffSwitchCfg", ["switchType"]);
+        },
+    },
 };
 // =============================================================================
 // Device Definitions
@@ -875,40 +1194,116 @@ exports.definitions = [
         model: "S4SW-001X8EU",
         vendor: "Shelly",
         description: "1 Mini Gen 4",
-        extend: [m.onOff({ powerOnBehavior: false }), ...shellyModernExtend.shellyCustomClusters(), shellyModernExtend.shellyWiFiSetup()],
+        ota: true,
+        fromZigbee: [fzLocal.one_switch_input_events, fzLocal.one_switch_input_scene_events, fzLocal.switch_input_type],
+        toZigbee: [tzLocal.switch_input_type],
+        exposes: [
+            e.action(["input_1_on", "input_1_off", "input_1_toggle", "input_1_hold"]),
+            e.enum("switch_type", ea.ALL, ["toggle", "momentary"]).withDescription("Switch input type").withCategory("config").withEndpoint("sw1"),
+        ],
+        extend: [
+            m.deviceEndpoints({ endpoints: { sw1: 2 } }),
+            m.onOff({ powerOnBehavior: false }),
+            ...shellyModernExtend.shellyCustomClusters(),
+            shellyModernExtend.shellyRPCSetup(["1PMInputMode"]),
+            shellyModernExtend.shellyWiFiSetup(),
+        ],
+        configure: async (device, coordinatorEndpoint) => {
+            const ep = device.getEndpoint(2);
+            if (ep) {
+                await ep.bind("genOnOff", coordinatorEndpoint);
+                await ep.bind("genScenes", coordinatorEndpoint);
+                await ep.read("genOnOffSwitchCfg", ["switchType"]);
+            }
+        },
     },
     {
         fingerprint: [{ modelID: "1", manufacturerName: "Shelly" }],
         model: "S4SW-001X16EU",
         vendor: "Shelly",
         description: "1 Gen 4",
-        extend: [m.onOff({ powerOnBehavior: false }), ...shellyModernExtend.shellyCustomClusters(), shellyModernExtend.shellyWiFiSetup()],
+        ota: true,
+        fromZigbee: [fzLocal.one_switch_input_events, fzLocal.one_switch_input_scene_events, fzLocal.switch_input_type],
+        toZigbee: [tzLocal.switch_input_type],
+        exposes: [
+            e.action(["input_1_on", "input_1_off", "input_1_toggle", "input_1_hold"]),
+            e.enum("switch_type", ea.ALL, ["toggle", "momentary"]).withDescription("Switch input type").withCategory("config").withEndpoint("sw1"),
+        ],
+        extend: [
+            m.deviceEndpoints({ endpoints: { sw1: 2 } }),
+            m.onOff({ powerOnBehavior: false }),
+            ...shellyModernExtend.shellyCustomClusters(),
+            shellyModernExtend.shellyRPCSetup(["1PMInputMode"]),
+            shellyModernExtend.shellyWiFiSetup(),
+        ],
+        configure: async (device, coordinatorEndpoint) => {
+            const ep = device.getEndpoint(2);
+            if (ep) {
+                await ep.bind("genOnOff", coordinatorEndpoint);
+                await ep.bind("genScenes", coordinatorEndpoint);
+                await ep.read("genOnOffSwitchCfg", ["switchType"]);
+            }
+        },
     },
     {
         zigbeeModel: ["Mini1PM", "1PM Mini"],
         model: "S4SW-001P8EU",
         vendor: "Shelly",
         description: "1PM Mini Gen 4",
+        ota: true,
+        fromZigbee: [fzLocal.one_switch_input_events, fzLocal.one_switch_input_scene_events, fzLocal.switch_input_type],
+        toZigbee: [tzLocal.switch_input_type],
+        exposes: [
+            e.action(["input_1_on", "input_1_off", "input_1_toggle", "input_1_hold"]),
+            e.enum("switch_type", ea.ALL, ["toggle", "momentary"]).withDescription("Switch input type").withCategory("config").withEndpoint("sw1"),
+        ],
         extend: [
+            m.deviceEndpoints({ endpoints: { sw1: 2 } }),
             m.onOff({ powerOnBehavior: false }),
             m.electricityMeter({ producedEnergy: true, acFrequency: true }),
             shellyModernExtend.shellyPowerFactorInt16Fix(),
             ...shellyModernExtend.shellyCustomClusters(),
+            shellyModernExtend.shellyRPCSetup(["1PMInputMode"]),
             shellyModernExtend.shellyWiFiSetup(),
         ],
+        configure: async (device, coordinatorEndpoint) => {
+            const ep = device.getEndpoint(2);
+            if (ep) {
+                await ep.bind("genOnOff", coordinatorEndpoint);
+                await ep.bind("genScenes", coordinatorEndpoint);
+                await ep.read("genOnOffSwitchCfg", ["switchType"]);
+            }
+        },
     },
     {
         zigbeeModel: ["1PM"],
         model: "S4SW-001P16EU",
         vendor: "Shelly",
         description: "1PM Gen 4",
+        ota: true,
+        fromZigbee: [fzLocal.one_switch_input_events, fzLocal.one_switch_input_scene_events, fzLocal.switch_input_type],
+        toZigbee: [tzLocal.switch_input_type],
+        exposes: [
+            e.action(["input_1_on", "input_1_off", "input_1_toggle", "input_1_hold"]),
+            e.enum("switch_type", ea.ALL, ["toggle", "momentary"]).withDescription("Switch input type").withCategory("config").withEndpoint("sw1"),
+        ],
         extend: [
+            m.deviceEndpoints({ endpoints: { sw1: 2 } }),
             m.onOff({ powerOnBehavior: false }),
             m.electricityMeter({ producedEnergy: true, acFrequency: true }),
             shellyModernExtend.shellyPowerFactorInt16Fix(),
             ...shellyModernExtend.shellyCustomClusters(),
+            shellyModernExtend.shellyRPCSetup(["1PMInputMode"]),
             shellyModernExtend.shellyWiFiSetup(),
         ],
+        configure: async (device, coordinatorEndpoint) => {
+            const ep = device.getEndpoint(2);
+            if (ep) {
+                await ep.bind("genOnOff", coordinatorEndpoint);
+                await ep.bind("genScenes", coordinatorEndpoint);
+                await ep.read("genOnOffSwitchCfg", ["switchType"]);
+            }
+        },
     },
     {
         zigbeeModel: ["EM Mini"],
@@ -922,6 +1317,25 @@ exports.definitions = [
             shellyModernExtend.shellyWiFiSetup(),
         ],
     },
+    {
+        fingerprint: [{ modelID: "EM", manufacturerName: "Shelly" }],
+        model: "S4EM-002CXCEU",
+        vendor: "Shelly",
+        description: "EM Gen4",
+        extend: [
+            m.deviceEndpoints({ endpoints: { "1": 1, "2": 2, "3": 3 } }),
+            m.onOff({ powerOnBehavior: false, endpointNames: ["1"] }),
+            m.electricityMeter({
+                endpointNames: ["2", "3"],
+                producedEnergy: true,
+                acFrequency: true,
+            }),
+            m.forcePowerSource({ powerSource: "Mains (single phase)" }),
+            shellyModernExtend.shellyPowerFactorInt16Fix(),
+            ...shellyModernExtend.shellyCustomClusters(),
+            shellyModernExtend.shellyWiFiSetup(),
+        ],
+    },
     {
         fingerprint: [
             {
@@ -934,11 +1348,48 @@ exports.definitions = [
                     { ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33] },
                 ],
             },
+            {
+                type: "Router",
+                manufacturerName: "Shelly",
+                modelID: "2PM",
+                endpoints: [
+                    { ID: 1, profileID: 260, deviceID: 514, inputClusters: [0, 3, 4, 5, 258], outputClusters: [25] },
+                    { ID: 2, inputClusters: [7], outputClusters: [3, 4, 5, 6] },
+                    { ID: 3, inputClusters: [7], outputClusters: [3, 4, 5, 6] },
+                    { ID: 4, inputClusters: [], outputClusters: [3, 4, 6, 8, 258] },
+                    { ID: 239, profileID: 49153, deviceID: 8193, inputClusters: [64513, 64514], outputClusters: [] },
+                    { ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33] },
+                ],
+            },
         ],
         model: "S4SW-002P16EU-COVER",
         vendor: "Shelly",
         description: "2PM Gen4 (Cover mode)",
-        extend: [m.windowCovering({ controls: ["lift", "tilt"] }), ...shellyModernExtend.shellyCustomClusters(), shellyModernExtend.shellyWiFiSetup()],
+        ota: true,
+        fromZigbee: [fzLocal.two_switch_inputs_events, fzLocal.two_switch_inputs_scene_events, fzLocal.switch_input_type],
+        toZigbee: [tzLocal.switch_input_type],
+        exposes: [
+            e.action(["input_1_on", "input_1_off", "input_1_toggle", "input_1_hold", "input_2_on", "input_2_off", "input_2_toggle", "input_2_hold"]),
+            e.enum("switch_type", ea.ALL, ["toggle", "momentary"]).withDescription("Switch input type").withCategory("config").withEndpoint("sw1"),
+            e.enum("switch_type", ea.ALL, ["toggle", "momentary"]).withDescription("Switch input type").withCategory("config").withEndpoint("sw2"),
+        ],
+        extend: [
+            m.deviceEndpoints({ endpoints: { sw1: 2, sw2: 3 } }),
+            m.windowCovering({ controls: ["lift", "tilt"] }),
+            ...shellyModernExtend.shellyCustomClusters(),
+            shellyModernExtend.shellyRPCSetup(["2PMInputMode"]),
+            shellyModernExtend.shellyWiFiSetup(),
+        ],
+        configure: async (device, coordinatorEndpoint) => {
+            for (const epID of [2, 3]) {
+                const ep = device.getEndpoint(epID);
+                if (ep) {
+                    await ep.bind("genOnOff", coordinatorEndpoint);
+                    await ep.bind("genScenes", coordinatorEndpoint);
+                    await ep.read("genOnOffSwitchCfg", ["switchType"]);
+                }
+            }
+        },
     },
     {
         fingerprint: [
@@ -953,18 +1404,51 @@ exports.definitions = [
                     { ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33] },
                 ],
             },
+            {
+                type: "Router",
+                manufacturerName: "Shelly",
+                modelID: "2PM",
+                endpoints: [
+                    { ID: 1, profileID: 260, deviceID: 266, inputClusters: [0, 3, 4, 5, 6, 2820, 1794], outputClusters: [25] },
+                    { ID: 2, profileID: 260, deviceID: 266, inputClusters: [4, 5, 6, 2820, 1794], outputClusters: [] },
+                    { ID: 3, inputClusters: [7], outputClusters: [3, 4, 5, 6] },
+                    { ID: 4, inputClusters: [7], outputClusters: [3, 4, 5, 6] },
+                    { ID: 5, inputClusters: [], outputClusters: [3, 4, 6, 8, 258] },
+                    { ID: 239, profileID: 49153, deviceID: 8193, inputClusters: [64513, 64514], outputClusters: [] },
+                    { ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33] },
+                ],
+            },
         ],
         model: "S4SW-002P16EU-SWITCH",
         vendor: "Shelly",
         description: "2PM Gen4 (Switch mode)",
+        ota: true,
+        fromZigbee: [fzLocal.two_switch_inputs_events, fzLocal.two_switch_inputs_scene_events, fzLocal.switch_input_type],
+        toZigbee: [tzLocal.switch_input_type],
+        exposes: [
+            e.action(["input_1_on", "input_1_off", "input_1_toggle", "input_1_hold", "input_2_on", "input_2_off", "input_2_toggle", "input_2_hold"]),
+            e.enum("switch_type", ea.ALL, ["toggle", "momentary"]).withDescription("Switch input type").withCategory("config").withEndpoint("sw1"),
+            e.enum("switch_type", ea.ALL, ["toggle", "momentary"]).withDescription("Switch input type").withCategory("config").withEndpoint("sw2"),
+        ],
         extend: [
-            m.deviceEndpoints({ endpoints: { l1: 1, l2: 2 } }),
+            m.deviceEndpoints({ endpoints: { l1: 1, l2: 2, sw1: 3, sw2: 4 } }),
             m.onOff({ powerOnBehavior: false, endpointNames: ["l1", "l2"] }),
             m.electricityMeter({ producedEnergy: true, acFrequency: true, endpointNames: ["l1", "l2"] }),
             shellyModernExtend.shellyPowerFactorInt16Fix(),
             ...shellyModernExtend.shellyCustomClusters(),
+            shellyModernExtend.shellyRPCSetup(["2PMInputMode"]),
             shellyModernExtend.shellyWiFiSetup(),
         ],
+        configure: async (device, coordinatorEndpoint) => {
+            for (const epID of [3, 4]) {
+                const ep = device.getEndpoint(epID);
+                if (ep) {
+                    await ep.bind("genOnOff", coordinatorEndpoint);
+                    await ep.bind("genScenes", coordinatorEndpoint);
+                    await ep.read("genOnOffSwitchCfg", ["switchType"]);
+                }
+            }
+        },
     },
     {
         fingerprint: [{ modelID: "Plug US", manufacturerName: "Shelly" }],
@@ -984,13 +1468,23 @@ exports.definitions = [
         model: "S4PL-00416EU",
         vendor: "Shelly",
         description: "Power strip 4 Gen4",
+        version: "0.0.1",
         extend: [
             m.deviceEndpoints({ endpoints: { "1": 1, "2": 2, "3": 3, "4": 4 } }),
             m.onOff({ powerOnBehavior: false, endpointNames: ["1", "2", "3", "4"] }),
-            m.electricityMeter({ endpointNames: ["1", "2", "3", "4"] }),
+            m.electricityMeter({
+                endpointNames: ["1", "2", "3", "4"],
+                // Reduce reporting to prevent crashes
+                // https://github.com/Koenkk/zigbee2mqtt/issues/31183
+                acFrequency: { change: 125 },
+                current: { change: 60 },
+                voltage: { change: 625 },
+                power: { change: 6 },
+                energy: { change: 125000 },
+            }),
             shellyModernExtend.shellyPowerFactorInt16Fix(),
             ...shellyModernExtend.shellyCustomClusters(),
-            shellyModernExtend.shellyRPCSetup(["PowerstripUI"]),
+            shellyModernExtend.shellyRPCSetup(["PowerstripUI", "PowerstripPowerOnBehavior"]),
             shellyModernExtend.shellyWiFiSetup(),
         ],
     },
@@ -1000,8 +1494,8 @@ exports.definitions = [
         vendor: "Shelly",
         description: "Flood Gen 4",
         extend: [
-            m.battery(),
-            m.iasZoneAlarm({ zoneType: "water_leak", zoneAttributes: ["alarm_1", "tamper", "battery_low"] }),
+            m.battery({ percentageReportingConfig: false }),
+            m.iasZoneAlarm({ zoneType: "water_leak", zoneAttributes: ["alarm_1", "tamper", "battery_low", "trouble"] }),
             ...shellyModernExtend.shellyCustomClusters(),
             shellyModernExtend.shellyWiFiSetup(),
         ],
@@ -1018,12 +1512,13 @@ exports.definitions = [
             m.pressure(),
             m.humidity(),
             m.deviceAddCustomCluster("shellyWS90Wind", {
+                name: "shellyWS90Wind",
                 ID: 0xfc01,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SHELLY,
                 attributes: {
-                    windSpeed: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
-                    windDirection: { ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
-                    gustSpeed: { ID: 0x0007, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+                    windSpeed: { name: "windSpeed", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+                    windDirection: { name: "windDirection", ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+                    gustSpeed: { name: "gustSpeed", ID: 0x0007, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
                 },
                 commands: {},
                 commandsResponse: {},
@@ -1065,10 +1560,11 @@ exports.definitions = [
                 access: "STATE_GET",
             }),
             m.deviceAddCustomCluster("shellyWS90UV", {
+                name: "shellyWS90UV",
                 ID: 0xfc02,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SHELLY,
                 attributes: {
-                    uvIndex: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    uvIndex: { name: "uvIndex", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
                 },
                 commands: {},
                 commandsResponse: {},
@@ -1085,11 +1581,12 @@ exports.definitions = [
                 access: "STATE_GET",
             }),
             m.deviceAddCustomCluster("shellyWS90Rain", {
+                name: "shellyWS90Rain",
                 ID: 0xfc03,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SHELLY,
                 attributes: {
-                    rainStatus: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
-                    precipitation: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT24 },
+                    rainStatus: { name: "rainStatus", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    precipitation: { name: "precipitation", ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT24 },
                 },
                 commands: {},
                 commandsResponse: {},
@@ -1121,7 +1618,10 @@ exports.definitions = [
         ],
     },
     {
-        fingerprint: [{ modelID: "Dimmer", manufacturerName: "Shelly" }],
+        fingerprint: [
+            { modelID: "Dimmer", manufacturerName: "Shelly" },
+            { modelID: "Dimmer US", manufacturerName: "Shelly" },
+        ],
         model: "S4DM-0A101WWL",
         vendor: "Shelly",
         description: "Dimmer Gen4",
@@ -1145,7 +1645,7 @@ exports.definitions = [
         model: "SBHT-103C",
         vendor: "Shelly",
         description: "BLU H&T display Zigbee",
-        extend: [m.battery(), m.temperature(), m.humidity()],
+        extend: [m.battery(), m.temperature(), m.humidity(), ...shellyModernExtend.shellyLightLevel()],
     },
     {
         fingerprint: [{ modelID: "BLU Remote Control ZB", manufacturerName: "Shelly" }],
@@ -1170,8 +1670,8 @@ exports.definitions = [
         model: "SBBT-102C",
         vendor: "Shelly",
         description: "BLU Button Tough 1 ZB",
-        fromZigbee: [fzLocal.one_button_events],
-        exposes: [e.action(["single", "double", "triple"])],
+        fromZigbee: [fzLocal.one_button_events, fzLocal.one_button_scene_events],
+        exposes: [e.action(["single", "double", "triple", "single_long", "double_long", "triple_long"])],
         extend: [m.battery(), m.deviceEndpoints({ endpoints: { "1": 1, "2": 2, "3": 3 } }), m.identify()],
         version: "0.0.2",
         configure: async (device, coordinatorEndpoint, definition) => {
@@ -1182,30 +1682,47 @@ exports.definitions = [
         },
     },
     {
-        fingerprint: [{ modelID: "BLU RC Button 4 ZB", manufacturerName: "Shelly" }],
+        zigbeeModel: ["BLU RC Button 4 ZB", "BLU Wall Switch 4 ZB", "BLU Wall Switch 4 ZB DK"],
         model: "SBBT-104CUS",
         vendor: "Shelly",
         description: "BLU RC Button 4 ZB",
-        fromZigbee: [fzLocal.four_buttons_single_events, fzLocal.four_buttons_hold_events],
-        exposes: [e.action(["1_single", "2_single", "3_single", "4_single", "1_hold", "2_hold", "3_hold", "4_hold"])],
-        extend: [m.battery(), m.deviceEndpoints({ endpoints: { "1": 1, "2": 2, "3": 3, "4": 4 } }), m.identify()],
-        version: "0.0.2",
-        configure: async (device, coordinatorEndpoint, definition) => {
-            for (const endpoint of device.endpoints) {
-                await endpoint.bind("genOnOff", coordinatorEndpoint);
-                await endpoint.bind("genLevelCtrl", coordinatorEndpoint);
-                await endpoint.bind("genScenes", coordinatorEndpoint);
-            }
-        },
-    },
-    {
-        zigbeeModel: ["BLU Wall Switch 4 ZB"],
-        model: "SBBT-004CEU",
-        vendor: "Shelly",
-        description: "BLU Wall Switch 4 ZB",
-        whiteLabel: [{ vendor: "Shelly", model: "SBBT-104CEU", description: "BLU Wall Switch 4 ZB DK" }],
-        fromZigbee: [fzLocal.four_buttons_single_events, fzLocal.four_buttons_hold_events],
-        exposes: [e.action(["1_single", "2_single", "3_single", "4_single", "1_hold", "2_hold", "3_hold", "4_hold"])],
+        whiteLabel: [
+            { vendor: "Shelly", model: "SBBT-004CEU", fingerprint: [{ modelID: "BLU Wall Switch 4 ZB" }], description: "BLU Wall Switch 4 ZB" },
+            { vendor: "Shelly", model: "SBBT-104CEU", fingerprint: [{ modelID: "BLU Wall Switch 4 ZB DK" }], description: "BLU Wall Switch 4 ZB DK" },
+        ],
+        fromZigbee: [fzLocal.four_buttons_single_events, fzLocal.four_buttons_hold_events, fzLocal.four_buttons_scene_events],
+        exposes: [
+            e.action([
+                "1_single",
+                "2_single",
+                "3_single",
+                "4_single",
+                "1_double",
+                "2_double",
+                "3_double",
+                "4_double",
+                "1_triple",
+                "2_triple",
+                "3_triple",
+                "4_triple",
+                "1_single_long",
+                "2_single_long",
+                "3_single_long",
+                "4_single_long",
+                "1_double_long",
+                "2_double_long",
+                "3_double_long",
+                "4_double_long",
+                "1_triple_long",
+                "2_triple_long",
+                "3_triple_long",
+                "4_triple_long",
+                "1_hold",
+                "2_hold",
+                "3_hold",
+                "4_hold",
+            ]),
+        ],
         extend: [m.battery(), m.deviceEndpoints({ endpoints: { "1": 1, "2": 2, "3": 3, "4": 4 } }), m.identify()],
         version: "0.0.2",
         configure: async (device, coordinatorEndpoint, definition) => {
@@ -1266,14 +1783,15 @@ exports.definitions = [
                 piHeatingDemand: { values: true },
             }),
             m.deviceAddCustomCluster("shellyTRVManualMode", {
+                name: "shellyTRVManualMode",
                 ID: 0xfc24,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SHELLY,
                 attributes: {
-                    manualMode: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
-                    position: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    manualMode: { name: "manualMode", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    position: { name: "position", ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
                 },
                 commands: {
-                    calibrate: { ID: 0x0000, parameters: [] },
+                    calibrate: { name: "calibrate", ID: 0x0000, parameters: [] },
                 },
                 commandsResponse: {},
             }),
@@ -1300,5 +1818,72 @@ exports.definitions = [
             m.identify(),
         ],
     },
+    {
+        fingerprint: [{ modelID: "Presence", manufacturerName: "Shelly" }],
+        model: "S4SN-0U61X",
+        vendor: "Shelly",
+        description: "Presence Gen4 Zigbee",
+        extend: [
+            m.deviceEndpoints({ endpoints: { "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, "10": 10 } }),
+            m.occupancy({ reporting: false, endpointNames: ["1"] }),
+            m.occupancy({ reporting: false, endpointNames: ["2"] }),
+            m.occupancy({ reporting: false, endpointNames: ["3"] }),
+            m.occupancy({ reporting: false, endpointNames: ["4"] }),
+            m.occupancy({ reporting: false, endpointNames: ["5"] }),
+            m.occupancy({ reporting: false, endpointNames: ["6"] }),
+            m.occupancy({ reporting: false, endpointNames: ["7"] }),
+            m.occupancy({ reporting: false, endpointNames: ["8"] }),
+            m.occupancy({ reporting: false, endpointNames: ["9"] }),
+            m.occupancy({ reporting: false, endpointNames: ["10"] }),
+            ...shellyModernExtend.shellyLightLevel(),
+            m.identify(),
+            ...shellyModernExtend.shellyCustomClusters(),
+            shellyModernExtend.shellyWiFiSetup(),
+        ],
+    },
+    {
+        fingerprint: [{ modelID: "BLU DoorWindow ZB", manufacturerName: "Shelly" }],
+        model: "SBDW-103C",
+        vendor: "Shelly",
+        description: "BLU DoorWindow ZB",
+        fromZigbee: [fzLocal.blu_door_window],
+        toZigbee: [],
+        exposes: [e.contact(), handlePosition, e.battery_low()],
+        extend: [m.battery(), ...shellyModernExtend.shellyLightLevel(), m.identify()],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            if (endpoint) {
+                await endpoint.read("ssIasZone", ["zoneStatus"]);
+            }
+        },
+    },
+    {
+        fingerprint: [{ modelID: "BLU Motion ZB", manufacturerName: "Shelly" }],
+        model: "SBMO-103Z",
+        vendor: "Shelly",
+        description: "BLU Motion ZB",
+        extend: [
+            m.iasZoneAlarm({ zoneType: "occupancy", zoneAttributes: ["alarm_1", "battery_low"] }),
+            m.battery(),
+            ...shellyModernExtend.shellyLightLevel(),
+            m.enumLookup({
+                name: "motion_sensitivity",
+                cluster: "ssIasZone",
+                attribute: "currentZoneSensitivityLevel",
+                lookup: { low: 1, medium: 2, high: 3 },
+                description: "Motion sensor sensitivity",
+                access: "ALL",
+                reporting: false,
+                entityCategory: "config",
+            }),
+            m.identify(),
+        ],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            if (endpoint) {
+                await endpoint.read("ssIasZone", ["currentZoneSensitivityLevel"]);
+            }
+        },
+    },
 ];
 //# sourceMappingURL=shelly.js.map