@willieee802/zigbee-herdsman-converters 19.44.4 → 19.45.0

package/dist/devices/sber.js

@@ -447,65 +447,76 @@ const sdevices = {
         },
     },
 };
-const sdevicesCustomClusterDefinition = {
+const sdevicesCustomCluster = {
+    name: "manuSpecificSDevices",
     ID: 0xfccf,
     manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
     attributes: {
-        buttonEnableMultiClick: { ID: 0x1002, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
-        childLock: { ID: 0x1003, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
-        ledIndicatorOnEnable: { ID: 0x2001, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
-        ledIndicatorOnH: { ID: 0x2002, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
-        ledIndicatorOnS: { ID: 0x2003, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-        ledIndicatorOnB: { ID: 0x2004, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-        ledIndicatorOffEnable: { ID: 0x2005, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
-        ledIndicatorOffH: { ID: 0x2006, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
-        ledIndicatorOffS: { ID: 0x2007, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-        ledIndicatorOffB: { ID: 0x2008, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-        emergencyShutoffState: { ID: 0x3001, type: zigbee_herdsman_1.Zcl.DataType.BITMAP16 },
-        emergencyShutoffRecovery: { ID: 0x3002, type: zigbee_herdsman_1.Zcl.DataType.BITMAP16, write: true, max: 0xffff },
-        upperVoltageThreshold: { ID: 0x3011, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
-        lowerVoltageThreshold: { ID: 0x3012, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
-        upperCurrentThreshold: { ID: 0x3013, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
-        upperTempThreshold: { ID: 0x3014, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, min: -32768 },
-        rmsVoltageMv: { ID: 0x4001, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
-        rmsCurrentMa: { ID: 0x4002, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
-        activePowerMw: { ID: 0x4003, type: zigbee_herdsman_1.Zcl.DataType.INT32 },
-        rtcStatus: { ID: 0x5001, type: zigbee_herdsman_1.Zcl.DataType.BITMAP16 },
+        buttonEnableMultiClick: { name: "buttonEnableMultiClick", ID: 0x1002, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+        childLock: { name: "childLock", ID: 0x1003, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+        ledIndicatorOnEnable: { name: "ledIndicatorOnEnable", ID: 0x2001, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+        ledIndicatorOnH: { name: "ledIndicatorOnH", ID: 0x2002, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
+        ledIndicatorOnS: { name: "ledIndicatorOnS", ID: 0x2003, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+        ledIndicatorOnB: { name: "ledIndicatorOnB", ID: 0x2004, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+        ledIndicatorOffEnable: { name: "ledIndicatorOffEnable", ID: 0x2005, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+        ledIndicatorOffH: { name: "ledIndicatorOffH", ID: 0x2006, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
+        ledIndicatorOffS: { name: "ledIndicatorOffS", ID: 0x2007, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+        ledIndicatorOffB: { name: "ledIndicatorOffB", ID: 0x2008, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+        ledIndicationType: { name: "ledIndicationType", ID: 0x2009, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+        emergencyShutoffState: { name: "emergencyShutoffState", ID: 0x3001, type: zigbee_herdsman_1.Zcl.DataType.BITMAP16 },
+        emergencyShutoffRecovery: { name: "emergencyShutoffRecovery", ID: 0x3002, type: zigbee_herdsman_1.Zcl.DataType.BITMAP16, write: true, max: 0xffff },
+        upperVoltageThreshold: { name: "upperVoltageThreshold", ID: 0x3011, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
+        lowerVoltageThreshold: { name: "lowerVoltageThreshold", ID: 0x3012, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
+        upperCurrentThreshold: { name: "upperCurrentThreshold", ID: 0x3013, type: zigbee_herdsman_1.Zcl.DataType.UINT32, write: true, max: 0xffffffff },
+        upperTempThreshold: { name: "upperTempThreshold", ID: 0x3014, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, min: -32768 },
+        rmsVoltageMv: { name: "rmsVoltageMv", ID: 0x4001, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+        rmsCurrentMa: { name: "rmsCurrentMa", ID: 0x4002, type: zigbee_herdsman_1.Zcl.DataType.UINT32 },
+        activePowerMw: { name: "activePowerMw", ID: 0x4003, type: zigbee_herdsman_1.Zcl.DataType.INT32 },
+        powerProfile: { name: "powerProfile", ID: 0x4100, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+        neutralPresence: { name: "neutralPresence", ID: 0x4101, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+        rtcStatus: { name: "rtcStatus", ID: 0x5001, type: zigbee_herdsman_1.Zcl.DataType.BITMAP16 },
     },
     commands: {},
     commandsResponse: {},
 };
 const sdevicesExtend = {
-    sdevicesCustomCluster: () => m.deviceAddCustomCluster("manuSpecificSDevices", sdevicesCustomClusterDefinition),
+    sdevicesCustomCluster: () => m.deviceAddCustomCluster("manuSpecificSDevices", sdevicesCustomCluster),
     haDiagnosticCluster: () => m.deviceAddCustomCluster("haDiagnostic", {
+        name: "haDiagnostic",
         ID: zigbee_herdsman_1.Zcl.Clusters.haDiagnostic.ID,
         attributes: {
             sdevicesUptimeS: {
+                name: "sdevicesUptimeS",
                 ID: 0x1001,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT32,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
             },
             sdevicesButton1Clicks: {
+                name: "sdevicesButton1Clicks",
                 ID: 0x1002,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT32,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
             },
             sdevicesButton2Clicks: {
+                name: "sdevicesButton2Clicks",
                 ID: 0x1003,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT32,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
             },
             sdevicesButton3Clicks: {
+                name: "sdevicesButton3Clicks",
                 ID: 0x1004,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT32,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
             },
             sdevicesRelay1Switches: {
+                name: "sdevicesRelay1Switches",
                 ID: 0x1005,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT32,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
             },
             sdevicesRelay2Switches: {
+                name: "sdevicesRelay2Switches",
                 ID: 0x1006,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT32,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -515,9 +526,11 @@ const sdevicesExtend = {
         commandsResponse: {},
     }),
     closuresWindowCoveringCluster: () => m.deviceAddCustomCluster("closuresWindowCovering", {
+        name: "closuresWindowCovering",
         ID: zigbee_herdsman_1.Zcl.Clusters.closuresWindowCovering.ID,
         attributes: {
             sdevicesCalibrationTime: {
+                name: "sdevicesCalibrationTime",
                 ID: 0x1001,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT16,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -525,6 +538,7 @@ const sdevicesExtend = {
                 max: 0xffff,
             },
             sdevicesButtonsMode: {
+                name: "sdevicesButtonsMode",
                 ID: 0x1002,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -532,6 +546,7 @@ const sdevicesExtend = {
                 max: 0x01,
             },
             sdevicesMotorTimeout: {
+                name: "sdevicesMotorTimeout",
                 ID: 0x1003,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT16,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -543,9 +558,11 @@ const sdevicesExtend = {
         commandsResponse: {},
     }),
     hvacThermostatCluster: () => m.deviceAddCustomCluster("hvacThermostat", {
+        name: "hvacThermostat",
         ID: zigbee_herdsman_1.Zcl.Clusters.hvacThermostat.ID,
         attributes: {
             sdevicesRemoteTemperature: {
+                name: "sdevicesRemoteTemperature",
                 ID: 0x4001,
                 type: zigbee_herdsman_1.Zcl.DataType.INT16,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -553,6 +570,7 @@ const sdevicesExtend = {
                 min: -32768,
             },
             sdevicesRemoteTemperatureCalibration: {
+                name: "sdevicesRemoteTemperatureCalibration",
                 ID: 0x4002,
                 type: zigbee_herdsman_1.Zcl.DataType.INT8,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -560,6 +578,7 @@ const sdevicesExtend = {
                 min: -128,
             },
             sdevicesSensorMode: {
+                name: "sdevicesSensorMode",
                 ID: 0x4003,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -567,6 +586,7 @@ const sdevicesExtend = {
                 max: 0x02,
             },
             sdevicesHeatingHysteresis: {
+                name: "sdevicesHeatingHysteresis",
                 ID: 0x4019,
                 type: zigbee_herdsman_1.Zcl.DataType.INT8,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -574,6 +594,7 @@ const sdevicesExtend = {
                 min: -128,
             },
             sdevicesMinLocalTemperatureLimit: {
+                name: "sdevicesMinLocalTemperatureLimit",
                 ID: 0x40f0,
                 type: zigbee_herdsman_1.Zcl.DataType.INT16,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -581,6 +602,7 @@ const sdevicesExtend = {
                 min: -32768,
             },
             sdevicesMaxLocalTemperatureLimit: {
+                name: "sdevicesMaxLocalTemperatureLimit",
                 ID: 0x40f1,
                 type: zigbee_herdsman_1.Zcl.DataType.INT16,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -588,6 +610,7 @@ const sdevicesExtend = {
                 min: -32768,
             },
             sdevicesOutputMode: {
+                name: "sdevicesOutputMode",
                 ID: 0x4100,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -595,15 +618,27 @@ const sdevicesExtend = {
                 max: 0xff,
             },
             sdevicesLocalSensorType: {
+                name: "sdevicesLocalSensorType",
                 ID: 0x4101,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
                 write: true,
                 max: 0xff,
             },
-            sdevicesSensorError: { ID: 0x4102, type: zigbee_herdsman_1.Zcl.DataType.BITMAP16, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD },
-            sdevicesEventStatus: { ID: 0x4103, type: zigbee_herdsman_1.Zcl.DataType.BITMAP16, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD },
+            sdevicesSensorError: {
+                name: "sdevicesSensorError",
+                ID: 0x4102,
+                type: zigbee_herdsman_1.Zcl.DataType.BITMAP16,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
+            },
+            sdevicesEventStatus: {
+                name: "sdevicesEventStatus",
+                ID: 0x4103,
+                type: zigbee_herdsman_1.Zcl.DataType.BITMAP16,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
+            },
             sdevicesRemoteSensorTimeout: {
+                name: "sdevicesRemoteSensorTimeout",
                 ID: 0x4203,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT16,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -615,9 +650,11 @@ const sdevicesExtend = {
         commandsResponse: {},
     }),
     hvacUserInterfaceCfgCluster: () => m.deviceAddCustomCluster("hvacUserInterfaceCfg", {
+        name: "hvacUserInterfaceCfg",
         ID: zigbee_herdsman_1.Zcl.Clusters.hvacUserInterfaceCfg.ID,
         attributes: {
             sdevicesBrightnessOperationsMode: {
+                name: "sdevicesBrightnessOperationsMode",
                 ID: 0x2001,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT16,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -625,6 +662,7 @@ const sdevicesExtend = {
                 max: 0xffff,
             },
             sdevicesBrightnessSteadyMode: {
+                name: "sdevicesBrightnessSteadyMode",
                 ID: 0x2002,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT16,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
@@ -636,9 +674,16 @@ const sdevicesExtend = {
         commandsResponse: {},
     }),
     genOnOffCluster: () => m.deviceAddCustomCluster("genOnOff", {
+        name: "genOnOff",
         ID: zigbee_herdsman_1.Zcl.Clusters.genOnOff.ID,
         attributes: {
-            sdevicesRelayDecouple: { ID: 0x10dc, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD, write: true },
+            sdevicesRelayDecouple: {
+                name: "sdevicesRelayDecouple",
+                ID: 0x10dc,
+                type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SBERDEVICES_LTD,
+                write: true,
+            },
         },
         commands: {},
         commandsResponse: {},
@@ -1165,6 +1210,32 @@ const sdevicesExtend = {
         }
         return extend;
     },
+    ledIndicationType: () => m.enumLookup({
+        name: "led_indication_type",
+        description: "Type of LED indication (ignored in cover controller mode). Either continuous light, or short flashes",
+        cluster: "manuSpecificSDevices",
+        attribute: "ledIndicationType",
+        lookup: { continuous: 0, flashes: 1 },
+        zigbeeCommandOptions: manufacturerOptions,
+    }),
+    powerProfile: () => m.enumLookup({
+        name: "power_profile",
+        description: "Power Profile when neutral wire is absent: quick mode is for fastest device response; anti-flicker (af) modes have different polling intervals (in ms). Anti-flicker fallback mode is the safest one: device will fall back to it automatically if unstable behavior has been detected in more responsive mode",
+        cluster: "manuSpecificSDevices",
+        attribute: "powerProfile",
+        lookup: { quick: 0, af_250: 1, af_500: 2, af_750: 3, af_1000: 4, af_1250: 5, af_1750: 6, af_2000: 7, af_fallback: 254 },
+        zigbeeCommandOptions: manufacturerOptions,
+    }),
+    neutralPresence: () => m.binary({
+        name: "neutral_presence",
+        cluster: "manuSpecificSDevices",
+        attribute: "neutralPresence",
+        description: "Neutral wire presence status",
+        valueOn: ["YES", 0x01],
+        valueOff: ["NO", 0x00],
+        access: "STATE_GET",
+        zigbeeCommandOptions: manufacturerOptions,
+    }),
 };
 exports.definitions = [
     {
@@ -1194,6 +1265,7 @@ exports.definitions = [
         vendor: "Sber",
         description: "Smart button",
         extend: [
+            tuya.clusters.addTuyaGenOnOffCluster(),
             tuyaMagicPacket(),
             tuyaOnOffActionLegacy({ actions: ["single", "double", "hold"] }),
             m.battery({ percentageReporting: false }),
@@ -1294,6 +1366,70 @@ exports.definitions = [
             await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ["haDiagnostic"]);
         },
     },
+    {
+        fingerprint: [{ modelID: "SBDV-00197", manufacturerName: "SDevices" }],
+        model: "SBDV-00197",
+        vendor: "Sber",
+        description: "Smart Wall Switch (optional neutral wire, single button)",
+        fromZigbee: [],
+        toZigbee: [],
+        extend: [
+            sdevicesExtend.sdevicesCustomCluster(),
+            sdevicesExtend.haDiagnosticCluster(),
+            sdevicesExtend.genOnOffCluster(),
+            m.binary({
+                name: "allow_double_click",
+                cluster: "manuSpecificSDevices",
+                attribute: "buttonEnableMultiClick",
+                description: "Allow detection of double clicks, may introduce delay in reaction when enabled",
+                valueOn: ["ON", 0x01],
+                valueOff: ["OFF", 0x00],
+                zigbeeCommandOptions: manufacturerOptions,
+            }),
+            sdevicesExtend.ledIndicatorSettings(),
+            m.identify(),
+            m.onOff({
+                powerOnBehavior: true,
+                configureReporting: false,
+            }),
+            sdevicesExtend.onOffRelayDecouple({
+                name: "relay_mode",
+                description: "Decoupled mode for button",
+            }),
+            m.actionEnumLookup({
+                cluster: "genMultistateInput",
+                attribute: "presentValue",
+                actionLookup: { hold: 0, single: 1, double: 2 },
+            }),
+            sdevicesExtend.childLock(),
+            sdevicesExtend.deviceInfo(),
+            sdevicesExtend.neutralPresence(),
+            sdevicesExtend.powerProfile(),
+            sdevicesExtend.ledIndicationType(),
+            sdevicesExtend.deviceCustomDiagnostic(2, 1),
+        ],
+        ota: true,
+        configure: async (device, coordinatorEndpoint) => {
+            await device.getEndpoint(1).read("genOnOff", ["onOff", "startUpOnOff"]);
+            await device.getEndpoint(1).read("genBasic", ["serialNumber"]);
+            await device
+                .getEndpoint(1)
+                .read("manuSpecificSDevices", [
+                "ledIndicatorOnEnable",
+                "ledIndicatorOnH",
+                "ledIndicatorOnS",
+                "ledIndicatorOnB",
+                "ledIndicatorOffEnable",
+                "ledIndicatorOffH",
+                "ledIndicatorOffS",
+                "ledIndicatorOffB",
+            ]);
+            await device.getEndpoint(1).read("manuSpecificSDevices", ["buttonEnableMultiClick"]);
+            await device.getEndpoint(1).read("manuSpecificSDevices", ["childLock"]);
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ["genOnOff", "genMultistateInput"]);
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ["haDiagnostic"]);
+        },
+    },
     {
         fingerprint: [{ modelID: "SBDV-00199", manufacturerName: "SDevices" }],
         model: "SBDV-00199",
@@ -1486,7 +1622,7 @@ exports.definitions = [
         ota: true,
         configure: async (device, coordinatorEndpoint) => {
             if (!device.customClusters.manuSpecificSDevices) {
-                device.addCustomCluster("manuSpecificSDevices", sdevicesCustomClusterDefinition);
+                device.addCustomCluster("manuSpecificSDevices", sdevicesCustomCluster);
             }
             const coveringEp = device.getEndpoint(3);
             if (coveringEp != null) {
@@ -1586,6 +1722,279 @@ exports.definitions = [
             device.save();
         },
     },
+    {
+        fingerprint: [{ modelID: "SBDV-00200", manufacturerName: "SDevices" }],
+        model: "SBDV-00200",
+        vendor: "Sber",
+        description: "Smart Wall Switch (optional neutral wire, two buttons)",
+        fromZigbee: [
+            fz.on_off,
+            fz.power_on_behavior,
+            sdevices.fz.cover_position_tilt,
+            sdevices.fz.multistate_input,
+            sdevices.fz.led_indicator_settings,
+            sdevices.fz.decouple_relay,
+            sdevices.fz.allow_double_click,
+            sdevices.fz.closures,
+        ],
+        toZigbee: [
+            sdevices.tz.custom_on_off,
+            tz.power_on_behavior,
+            tz.cover_position_tilt,
+            sdevices.tz.cover_state,
+            sdevices.tz.cover_mode,
+            sdevices.tz.identify,
+            sdevices.tz.led_indicator_on_settings,
+            sdevices.tz.led_indicator_off_settings,
+            sdevices.tz.decouple_relay,
+            sdevices.tz.allow_double_click,
+            sdevices.tz.closures_custom,
+        ],
+        exposes: (device, options) => {
+            const switchExposes = [];
+            const coversEpName = "cover";
+            const coversExposes = [
+                e.enum("state", ea.STATE_SET, ["OPEN", "CLOSE", "STOP"]).withProperty("current_state").withEndpoint(coversEpName),
+                e
+                    .numeric("position", ea.ALL)
+                    .withValueMin(0)
+                    .withValueMax(100)
+                    .withDescription("Position of this cover, 100 is fully open if 'Invert cover' option is false (default)")
+                    .withUnit("%")
+                    .withEndpoint(coversEpName),
+                e
+                    .composite("cover_mode", "cover_mode", ea.ALL)
+                    .withFeature(e.binary("reversed", ea.ALL, true, false).withDescription("Reversal of the motor rotating direction"))
+                    .withEndpoint(coversEpName),
+                e
+                    .numeric("calibration_time", ea.ALL)
+                    .withValueMin(0)
+                    .withValueMax(3600)
+                    .withValueStep(0.1)
+                    .withDescription("Calibration time")
+                    .withUnit("s")
+                    .withEndpoint(coversEpName),
+                e
+                    .numeric("motor_timeout", ea.ALL)
+                    .withValueMin(0)
+                    .withValueMax(3600)
+                    .withDescription("Timeout for continuous motor action")
+                    .withUnit("s")
+                    .withEndpoint(coversEpName),
+                e.enum("buttons_mode", ea.ALL, ["normal", "inverted"]).withProperty("buttons_mode").withEndpoint(coversEpName),
+                e
+                    .enum("identify", ea.SET, ["identify"])
+                    .withLabel("Identify")
+                    .withDescription("Initiate device identification")
+                    .withCategory("config")
+                    .withEndpoint(coversEpName),
+                e
+                    .binary("led_indicator_off_enable", ea.ALL, "ON", "OFF")
+                    .withLabel("LED indication")
+                    .withDescription("Is LED indicator enabled")
+                    .withEndpoint(coversEpName),
+                e
+                    .numeric("led_indicator_off_h", ea.ALL)
+                    .withUnit("°")
+                    .withValueMin(0)
+                    .withValueMax(359)
+                    .withLabel("Hue")
+                    .withDescription("Hue of LED indicator")
+                    .withEndpoint(coversEpName),
+                e
+                    .numeric("led_indicator_off_s", ea.ALL)
+                    .withValueMin(0)
+                    .withValueMax(0xfe)
+                    .withLabel("Saturation")
+                    .withDescription("Saturation of LED indicator")
+                    .withEndpoint(coversEpName),
+                e
+                    .numeric("led_indicator_off_b", ea.ALL)
+                    .withValueMin(1)
+                    .withValueMax(0xfe)
+                    .withLabel("Brightness")
+                    .withDescription("Brightness of LED indicator")
+                    .withEndpoint(coversEpName),
+            ];
+            const endpointsCount = 2;
+            switchExposes.push(e.action(["hold_switch_1", "hold_switch_2", "single_switch_1", "single_switch_2", "double_switch_1", "double_switch_2"]));
+            for (let i = 1; i <= endpointsCount; i++) {
+                const epName = `switch_${i}`;
+                const epPrefix = `(${i}) `;
+                switchExposes.push(e.switch().withEndpoint(epName));
+                switchExposes.push(e.power_on_behavior(["off", "on", "toggle", "previous"]).withLabel(`${epPrefix}Power-on behavior`).withEndpoint(epName));
+                switchExposes.push(e
+                    .enum("relay_mode", ea.ALL, ["control_relay", "decoupled"])
+                    .withLabel(`${epPrefix}Relay mode`)
+                    .withDescription("Decoupled mode")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .binary("allow_double_click", ea.ALL, "ON", "OFF")
+                    .withLabel(`${epPrefix}Allow double clicks`)
+                    .withDescription("Allow detection of double clicks, may introduce delay in reaction when enabled")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .enum("identify", ea.SET, ["identify"])
+                    .withLabel(`${epPrefix}Identify`)
+                    .withDescription("Initiate device identification")
+                    .withCategory("config")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .binary("led_indicator_on_enable", ea.ALL, "ON", "OFF")
+                    .withLabel(`${epPrefix}LED indication`)
+                    .withDescription("Is LED indicator enabled in ON state")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .numeric("led_indicator_on_h", ea.ALL)
+                    .withUnit("°")
+                    .withValueMin(0)
+                    .withValueMax(359)
+                    .withLabel(`${epPrefix}Hue`)
+                    .withDescription("Hue of LED in ON state")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .numeric("led_indicator_on_s", ea.ALL)
+                    .withValueMin(0)
+                    .withValueMax(0xfe)
+                    .withLabel(`${epPrefix}Saturation`)
+                    .withDescription("Saturation of LED in ON state")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .numeric("led_indicator_on_b", ea.ALL)
+                    .withValueMin(1)
+                    .withValueMax(0xfe)
+                    .withLabel(`${epPrefix}Brightness`)
+                    .withDescription("Brightness of LED in ON state")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .binary("led_indicator_off_enable", ea.ALL, "ON", "OFF")
+                    .withLabel(`${epPrefix}LED indication`)
+                    .withDescription("Is LED indicator enabled in OFF state")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .numeric("led_indicator_off_h", ea.ALL)
+                    .withUnit("°")
+                    .withValueMin(0)
+                    .withValueMax(359)
+                    .withLabel(`${epPrefix}Hue`)
+                    .withDescription("Hue of LED in OFF state")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .numeric("led_indicator_off_s", ea.ALL)
+                    .withValueMin(0)
+                    .withValueMax(0xfe)
+                    .withLabel(`${epPrefix}Saturation`)
+                    .withDescription("Saturation of LED in OFF state")
+                    .withEndpoint(epName));
+                switchExposes.push(e
+                    .numeric("led_indicator_off_b", ea.ALL)
+                    .withValueMin(1)
+                    .withValueMax(0xfe)
+                    .withLabel(`${epPrefix}Brightness`)
+                    .withDescription("Brightness of LED in OFF state")
+                    .withEndpoint(epName));
+            }
+            if (!utils.isDummyDevice(device)) {
+                return device.meta.window_covering_enabled ? [...coversExposes] : [...switchExposes];
+            }
+            return [...switchExposes, ...coversExposes];
+        },
+        extend: [
+            m.deviceEndpoints({ endpoints: { switch_1: 1, switch_2: 2, cover: 3 } }),
+            sdevicesExtend.sdevicesCustomCluster(),
+            sdevicesExtend.haDiagnosticCluster(),
+            sdevicesExtend.genOnOffCluster(),
+            sdevicesExtend.closuresWindowCoveringCluster(),
+            sdevicesExtend.childLock(),
+            sdevicesExtend.deviceInfo(),
+            sdevicesExtend.neutralPresence(),
+            sdevicesExtend.powerProfile(),
+            sdevicesExtend.ledIndicationType(),
+            sdevicesExtend.deviceCustomDiagnostic(3, 2),
+        ],
+        ota: true,
+        configure: async (device, coordinatorEndpoint) => {
+            if (!device.customClusters.manuSpecificSDevices) {
+                device.addCustomCluster("manuSpecificSDevices", sdevicesCustomCluster);
+            }
+            const coveringEp = device.getEndpoint(3);
+            if (coveringEp != null) {
+                try {
+                    const deviceCoverMode = await device.getEndpoint(3).read("genBasic", ["deviceEnabled"]);
+                    device.meta.window_covering_enabled = !!deviceCoverMode.deviceEnabled;
+                    device.save();
+                }
+                catch (error) {
+                    if (error.message.includes("UNSUPPORTED_ATTRIBUTE")) {
+                        device.meta.window_covering_enabled = false;
+                        device.save();
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            else {
+                device.meta.window_covering_enabled = false;
+                device.save();
+            }
+            if (device.meta.window_covering_enabled) {
+                /* Device is in Window Covering mode */
+                await device.getEndpoint(3).read("genBasic", ["serialNumber"]);
+                await device.getEndpoint(3).read("closuresWindowCovering", ["currentPositionLiftPercentage", "windowCoveringMode"]);
+                await device
+                    .getEndpoint(3)
+                    .read("closuresWindowCovering", ["sdevicesCalibrationTime", "sdevicesButtonsMode", "sdevicesMotorTimeout"], manufacturerOptions);
+                await device
+                    .getEndpoint(3)
+                    .read("manuSpecificSDevices", ["ledIndicatorOffEnable", "ledIndicatorOffH", "ledIndicatorOffS", "ledIndicatorOffB"], manufacturerOptions);
+                await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ["closuresWindowCovering"]);
+                await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ["manuSpecificSDevices"]);
+                await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ["haDiagnostic"]);
+                await device.getEndpoint(3).read("manuSpecificSDevices", ["childLock"]);
+            }
+            else {
+                /* Device is in 2-button Switch mode */
+                await device.getEndpoint(1).read("genBasic", ["serialNumber"]);
+                await device.getEndpoint(1).read("genOnOff", ["onOff", "startUpOnOff"]);
+                await device.getEndpoint(2).read("genOnOff", ["onOff", "startUpOnOff"]);
+                await device.getEndpoint(1).read("genOnOff", ["sdevicesRelayDecouple"], manufacturerOptions);
+                await device.getEndpoint(2).read("genOnOff", ["sdevicesRelayDecouple"], manufacturerOptions);
+                await device
+                    .getEndpoint(1)
+                    .read("manuSpecificSDevices", [
+                    "buttonEnableMultiClick",
+                    "ledIndicatorOnEnable",
+                    "ledIndicatorOnH",
+                    "ledIndicatorOnS",
+                    "ledIndicatorOnB",
+                    "ledIndicatorOffEnable",
+                    "ledIndicatorOffH",
+                    "ledIndicatorOffS",
+                    "ledIndicatorOffB",
+                ], manufacturerOptions);
+                await device
+                    .getEndpoint(2)
+                    .read("manuSpecificSDevices", [
+                    "buttonEnableMultiClick",
+                    "ledIndicatorOnEnable",
+                    "ledIndicatorOnH",
+                    "ledIndicatorOnS",
+                    "ledIndicatorOnB",
+                    "ledIndicatorOffEnable",
+                    "ledIndicatorOffH",
+                    "ledIndicatorOffS",
+                    "ledIndicatorOffB",
+                ], manufacturerOptions);
+                await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ["genOnOff", "genMultistateInput"]);
+                await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ["genOnOff", "genMultistateInput"]);
+                await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ["manuSpecificSDevices"]);
+                await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ["haDiagnostic"]);
+                await device.getEndpoint(1).read("manuSpecificSDevices", ["childLock"]);
+            }
+            device.save();
+        },
+    },
     {
         fingerprint: [{ modelID: "SBDV-00202", manufacturerName: "SDevices" }],
         model: "SBDV-00202",