@willieee802/zigbee-herdsman-converters 19.44.3 → 19.45.0

package/dist/devices/schneider_electric.js

@@ -39,12 +39,15 @@ const fz = __importStar(require("../converters/fromZigbee"));
 const tz = __importStar(require("../converters/toZigbee"));
 const constants = __importStar(require("../lib/constants"));
 const exposes = __importStar(require("../lib/exposes"));
+const logger_1 = require("../lib/logger");
 const m = __importStar(require("../lib/modernExtend"));
 const reporting = __importStar(require("../lib/reporting"));
+const globalStore = __importStar(require("../lib/store"));
 const utils = __importStar(require("../lib/utils"));
 const utils_1 = require("../lib/utils");
 const e = exposes.presets;
 const ea = exposes.access;
+const NS = "zhc:schneider_electric";
 function indicatorMode(endpoint) {
     let description = "Set Indicator Mode.";
     if (endpoint) {
@@ -150,20 +153,21 @@ function switchActions(endpoint) {
 }
 const schneiderElectricExtend = {
     addVisaConfigurationCluster: (enumDataType) => m.deviceAddCustomCluster("visaConfiguration", {
+        name: "visaConfiguration",
         ID: 0xfc04,
         manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
         attributes: {
-            indicatorLuminanceLevel: { ID: 0x0000, type: enumDataType, write: true },
-            indicatorColor: { ID: 0x0001, type: enumDataType, write: true },
-            indicatorMode: { ID: 0x0002, type: enumDataType, write: true },
-            motorTypeChannel1: { ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            motorTypeChannel2: { ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            curtainStatusChannel1: { ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            curtainStatusChannel2: { ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            key1EventNotification: { ID: 0x0020, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            key2EventNotification: { ID: 0x0021, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            key3EventNotification: { ID: 0x0022, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            key4EventNotification: { ID: 0x0023, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            indicatorLuminanceLevel: { name: "indicatorLuminanceLevel", ID: 0x0000, type: enumDataType, write: true },
+            indicatorColor: { name: "indicatorColor", ID: 0x0001, type: enumDataType, write: true },
+            indicatorMode: { name: "indicatorMode", ID: 0x0002, type: enumDataType, write: true },
+            motorTypeChannel1: { name: "motorTypeChannel1", ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            motorTypeChannel2: { name: "motorTypeChannel2", ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            curtainStatusChannel1: { name: "curtainStatusChannel1", ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            curtainStatusChannel2: { name: "curtainStatusChannel2", ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            key1EventNotification: { name: "key1EventNotification", ID: 0x0020, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            key2EventNotification: { name: "key2EventNotification", ID: 0x0021, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            key3EventNotification: { name: "key3EventNotification", ID: 0x0022, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            key4EventNotification: { name: "key4EventNotification", ID: 0x0023, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
         },
         commands: {},
         commandsResponse: {},
@@ -338,13 +342,14 @@ const schneiderElectricExtend = {
         return extend;
     },
     addOccupancyConfigurationCluster: () => m.deviceAddCustomCluster("occupancyConfiguration", {
+        name: "occupancyConfiguration",
         ID: 0xff19,
         manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
         attributes: {
-            ambienceLightThreshold: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
-            occupancyActions: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
-            unoccupiedLevelDflt: { ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            unoccupiedLevel: { ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            ambienceLightThreshold: { name: "ambienceLightThreshold", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
+            occupancyActions: { name: "occupancyActions", ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            unoccupiedLevelDflt: { name: "unoccupiedLevelDflt", ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            unoccupiedLevel: { name: "unoccupiedLevel", ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
         },
         commands: {},
         commandsResponse: {},
@@ -389,60 +394,56 @@ const schneiderElectricExtend = {
         extend.configure.push(m.setupConfigureForReading("occupancyConfiguration", ["ambienceLightThreshold"]));
         return extend;
     },
-    thermostatWithPower: (options) => {
-        const extend = m.thermostat(options);
-        const climateExpose = extend.exposes.find((exp) => typeof exp !== "function" && "type" in exp && exp.type === "climate");
-        if (climateExpose) {
-            climateExpose.withRunningState(["idle", "heat"]);
-            const runningStateFeature = climateExpose.features.find((f) => typeof f !== "function" && "name" in f && f.name === "running_state");
-            if (runningStateFeature) {
-                runningStateFeature.withDescription("Running state based on power draw (>10W)");
-            }
-        }
-        extend.fromZigbee.push({
-            cluster: "seMetering",
-            type: ["attributeReport", "readResponse"],
-            convert: (model, msg, publish, options, meta) => {
-                if ("instantaneousDemand" in msg.data) {
-                    const w = Math.max(0, Number(msg.data.instantaneousDemand));
-                    return { running_state: w > 10 ? "heat" : "idle" };
-                }
-            },
-        });
-        return extend;
+    runningStateFromPower: () => {
+        return {
+            isModernExtend: true,
+            fromZigbee: [
+                {
+                    cluster: "seMetering",
+                    type: ["attributeReport", "readResponse"],
+                    convert: (model, msg, publish, options, meta) => {
+                        if ("instantaneousDemand" in msg.data) {
+                            const w = Math.max(0, Number(msg.data.instantaneousDemand));
+                            return { running_state: w > 10 ? "heat" : "idle" };
+                        }
+                    },
+                },
+            ],
+        };
     },
     addHeatingCoolingOutputClusterServer: () => m.deviceAddCustomCluster("heatingCoolingOutputClusterServer", {
+        name: "heatingCoolingOutputClusterServer",
         ID: 0xff23,
         manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
         attributes: {
-            measuredTemperature: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
-            absMinHeatTemperatureLimit: { ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
-            absMaxHeatTemperatureLimit: { ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
-            absMinCoolTemperatureLimit: { ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
-            absMaxCoolTemperatureLimit: { ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
-            minHeatTemperatureLimit: { ID: 0x0015, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
-            maxHeatTemperatureLimit: { ID: 0x0016, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
-            minCoolTemperatureLimit: { ID: 0x0017, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
-            maxCoolTemperatureLimit: { ID: 0x0018, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
-            heatTemperatureHighLimit: { ID: 0x0020, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
-            heatTemperatureLowLimit: { ID: 0x0021, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
-            coolTemperatureHighLimit: { ID: 0x0022, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
-            coolTemperatureLowLimit: { ID: 0x0023, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
-            coolingOutputMode: { ID: 0x0030, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true },
-            heatingOutputMode: { ID: 0x0031, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true },
-            maximumIdleTime: { ID: 0x0041, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 8784 },
-            antiIdleExerciseTime: { ID: 0x0042, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 3600 },
-            preferredExerciseTime: { ID: 0x0043, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 1439 },
-            minOffTime: { ID: 0x0044, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true },
-            minOnTime: { ID: 0x0045, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true },
-            maxOverallDutyCycle: { ID: 0xe207, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, min: 900, max: 3600 },
-            overallDutyCyclePeriod: { ID: 0xe208, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 1440 },
-            clusterRevision: { ID: 0xfffd, type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xfffe },
+            measuredTemperature: { name: "measuredTemperature", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
+            absMinHeatTemperatureLimit: { name: "absMinHeatTemperatureLimit", ID: 0x0003, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
+            absMaxHeatTemperatureLimit: { name: "absMaxHeatTemperatureLimit", ID: 0x0004, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
+            absMinCoolTemperatureLimit: { name: "absMinCoolTemperatureLimit", ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
+            absMaxCoolTemperatureLimit: { name: "absMaxCoolTemperatureLimit", ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.INT16, max: 0x7fff },
+            minHeatTemperatureLimit: { name: "minHeatTemperatureLimit", ID: 0x0015, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
+            maxHeatTemperatureLimit: { name: "maxHeatTemperatureLimit", ID: 0x0016, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
+            minCoolTemperatureLimit: { name: "minCoolTemperatureLimit", ID: 0x0017, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
+            maxCoolTemperatureLimit: { name: "maxCoolTemperatureLimit", ID: 0x0018, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
+            heatTemperatureHighLimit: { name: "heatTemperatureHighLimit", ID: 0x0020, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
+            heatTemperatureLowLimit: { name: "heatTemperatureLowLimit", ID: 0x0021, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
+            coolTemperatureHighLimit: { name: "coolTemperatureHighLimit", ID: 0x0022, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
+            coolTemperatureLowLimit: { name: "coolTemperatureLowLimit", ID: 0x0023, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, max: 0x7fff },
+            coolingOutputMode: { name: "coolingOutputMode", ID: 0x0030, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true },
+            heatingOutputMode: { name: "heatingOutputMode", ID: 0x0031, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true },
+            maximumIdleTime: { name: "maximumIdleTime", ID: 0x0041, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 8784 },
+            antiIdleExerciseTime: { name: "antiIdleExerciseTime", ID: 0x0042, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 3600 },
+            preferredExerciseTime: { name: "preferredExerciseTime", ID: 0x0043, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 1439 },
+            minOffTime: { name: "minOffTime", ID: 0x0044, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true },
+            minOnTime: { name: "minOnTime", ID: 0x0045, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true },
+            maxOverallDutyCycle: { name: "maxOverallDutyCycle", ID: 0xe207, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, min: 900, max: 3600 },
+            overallDutyCyclePeriod: { name: "overallDutyCyclePeriod", ID: 0xe208, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 1440 },
+            clusterRevision: { name: "clusterRevision", ID: 0xfffd, type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xfffe },
         },
         commands: {},
         commandsResponse: {},
     }),
-    heatingOutputMode: () => m.enumLookup({
+    heatingOutputMode: (args) => m.enumLookup({
         name: "heating_output_mode",
         cluster: "heatingCoolingOutputClusterServer",
         attribute: "heatingOutputMode",
@@ -457,8 +458,9 @@ const schneiderElectricExtend = {
             "Relay NC": 4,
         },
         zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
+        ...args,
     }),
-    pilotMode: () => m.enumLookup({
+    pilotMode: (args) => m.enumLookup({
         name: "schneider_pilot_mode",
         cluster: "heatingCoolingOutputClusterServer",
         attribute: "heatingOutputMode",
@@ -470,11 +472,14 @@ const schneiderElectricExtend = {
             pilot: 3,
         },
         zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
+        ...args,
     }),
     addHvacUserInterfaceCfgCustomAttributes: () => m.deviceAddCustomCluster("hvacUserInterfaceCfg", {
+        name: "hvacUserInterfaceCfg",
         ID: zigbee_herdsman_1.Zcl.Clusters.hvacUserInterfaceCfg.ID,
         attributes: {
             displayBrightnessActive: {
+                name: "displayBrightnessActive",
                 ID: 0xe000,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT8,
                 write: true,
@@ -483,6 +488,7 @@ const schneiderElectricExtend = {
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             displayBrightnessInactive: {
+                name: "displayBrightnessInactive",
                 ID: 0xe001,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT8,
                 write: true,
@@ -491,6 +497,7 @@ const schneiderElectricExtend = {
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             displayActiveTimeout: {
+                name: "displayActiveTimeout",
                 ID: 0xe002,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT16,
                 write: true,
@@ -502,7 +509,7 @@ const schneiderElectricExtend = {
         commands: {},
         commandsResponse: {},
     }),
-    displayBrightnessActive: () => m.numeric({
+    displayBrightnessActive: (args) => m.numeric({
         name: "display_brightness_active",
         cluster: "hvacUserInterfaceCfg",
         attribute: "displayBrightnessActive",
@@ -513,8 +520,9 @@ const schneiderElectricExtend = {
         valueMax: 100,
         valueStep: 1,
         zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
+        ...args,
     }),
-    displayBrightnessInactive: () => m.numeric({
+    displayBrightnessInactive: (args) => m.numeric({
         name: "display_brightness_inactive",
         cluster: "hvacUserInterfaceCfg",
         attribute: "displayBrightnessInactive",
@@ -525,8 +533,9 @@ const schneiderElectricExtend = {
         valueMax: 100,
         valueStep: 1,
         zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
+        ...args,
     }),
-    displayActiveTimeout: () => m.numeric({
+    displayActiveTimeout: (args) => m.numeric({
         name: "display_active_timeout",
         cluster: "hvacUserInterfaceCfg",
         attribute: "displayActiveTimeout",
@@ -537,11 +546,14 @@ const schneiderElectricExtend = {
         valueMax: 600,
         valueStep: 5,
         zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
+        ...args,
     }),
     customTemperatureMeasurementCluster: () => m.deviceAddCustomCluster("msTemperatureMeasurement", {
+        name: "msTemperatureMeasurement",
         ID: zigbee_herdsman_1.Zcl.Clusters.msTemperatureMeasurement.ID,
         attributes: {
             sensorCorrection: {
+                name: "sensorCorrection",
                 ID: 0xe020,
                 type: zigbee_herdsman_1.Zcl.DataType.INT16,
                 write: true,
@@ -550,6 +562,7 @@ const schneiderElectricExtend = {
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             temperatureSensorType: {
+                name: "temperatureSensorType",
                 ID: 0xe021,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 write: true,
@@ -559,10 +572,46 @@ const schneiderElectricExtend = {
         commands: {},
         commandsResponse: {},
     }),
+    sensorCorrection: (args) => m.numeric({
+        name: "temperature_sensor_correction",
+        cluster: "msTemperatureMeasurement",
+        attribute: "sensorCorrection",
+        description: "This is a user correction, possibly negative, to be added to the temperature measured by the sensor.",
+        unit: "°C",
+        scale: 100,
+        valueMin: -9,
+        valueMax: 9,
+        valueStep: 0.01,
+        access: "ALL",
+        entityCategory: "config",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
+        ...args,
+    }),
+    temperatureSensorType: (args) => m.enumLookup({
+        name: "temperature_sensor_type",
+        cluster: "msTemperatureMeasurement",
+        attribute: "temperatureSensorType",
+        description: "This is used to specify the type of temperature sensor connected to this input",
+        entityCategory: "config",
+        access: "ALL",
+        lookup: {
+            "2kΩ sensor from HRT/Alre": 1,
+            "10kΩ sensor from B+J": 2,
+            "12kΩ sensor from OJ": 3,
+            "15kΩ sensor from DEVI": 4,
+            "33kΩ sensor from EBERLE": 5,
+            "47kΩ sensor from CTM": 6,
+            "No sensor": 0xff,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
+        ...args,
+    }),
     customMeteringCluster: () => m.deviceAddCustomCluster("seMetering", {
+        name: "seMetering",
         ID: zigbee_herdsman_1.Zcl.Clusters.seMetering.ID,
         attributes: {
             fixedLoadDemand: {
+                name: "fixedLoadDemand",
                 ID: 0x4510,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT24,
                 write: true,
@@ -573,26 +622,38 @@ const schneiderElectricExtend = {
         commands: {},
         commandsResponse: {},
     }),
-    fixedLoadDemand: () => m.numeric({
+    fixedLoadDemand: (args) => m.numeric({
         name: "fixed_load_demand",
         cluster: "seMetering",
         attribute: "fixedLoadDemand",
-        description: "This attribute specifies the demand of a switched load when it is energised",
+        description: "Load in W when heating is on (between 0-3600 W). The thermostat reports this value as power (instantaneousDemand) when heating is on. The load has to be defined if the device should report running state ('heat' or 'idle').",
         entityCategory: "config",
         unit: "W",
         valueMin: 1,
         valueMax: 3600,
         valueStep: 1,
+        ...args,
     }),
     customThermostatCluster: () => m.deviceAddCustomCluster("hvacThermostat", {
+        name: "hvacThermostat",
         ID: zigbee_herdsman_1.Zcl.Clusters.hvacThermostat.ID,
         attributes: {
+            schneiderWiserSpecific: {
+                name: "schneiderWiserSpecific",
+                ID: 0xe110,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                write: true,
+                max: 0xff,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+            },
             controlStatus: {
+                name: "controlStatus",
                 ID: 0xe211,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             localTemperatureSourceSelect: {
+                name: "localTemperatureSourceSelect",
                 ID: 0xe212,
                 type: zigbee_herdsman_1.Zcl.DataType.UINT8,
                 write: true,
@@ -600,40 +661,109 @@ const schneiderElectricExtend = {
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             controlType: {
+                name: "controlType",
                 ID: 0xe213,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 write: true,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             thermostatApplication: {
+                name: "thermostatApplication",
                 ID: 0xe216,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 write: true,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             heatingFuel: {
+                name: "heatingFuel",
                 ID: 0xe217,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 write: true,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             heatTransferMedium: {
+                name: "heatTransferMedium",
                 ID: 0xe218,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 write: true,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
             heatingEmitter: {
+                name: "heatingEmitter",
                 ID: 0xe21a,
                 type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
                 write: true,
                 manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
             },
+            wiserSmartZoneMode: {
+                name: "wiserSmartZoneMode",
+                ID: 0xe010,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                write: true,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+            },
+            wiserSmartHactConfig: {
+                name: "wiserSmartHactConfig",
+                ID: 0xe011,
+                type: zigbee_herdsman_1.Zcl.DataType.BITMAP8,
+                write: true,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+            },
+            wiserSmartCurrentFilPiloteMode: {
+                name: "wiserSmartCurrentFilPiloteMode",
+                ID: 0xe020,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                write: true,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+            },
+            wiserSmartValvePosition: {
+                name: "wiserSmartValvePosition",
+                ID: 0xe030,
+                type: zigbee_herdsman_1.Zcl.DataType.UINT8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+            },
+            wiserSmartValveCalibrationStatus: {
+                name: "wiserSmartValveCalibrationStatus",
+                ID: 0xe031,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+            },
+        },
+        commands: {
+            schneiderWiserThermostatBoost: {
+                name: "schneiderWiserThermostatBoost",
+                ID: 0x80,
+                parameters: [
+                    { name: "command", type: zigbee_herdsman_1.Zcl.DataType.ENUM8, max: 0xff },
+                    { name: "enable", type: zigbee_herdsman_1.Zcl.DataType.ENUM8, max: 0xff },
+                    { name: "temperature", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                    { name: "duration", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                ],
+            },
+            wiserSmartSetSetpoint: {
+                name: "wiserSmartSetSetpoint",
+                ID: 0xe0,
+                parameters: [
+                    { name: "operatingmode", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                    { name: "zonemode", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                    { name: "setpoint", type: zigbee_herdsman_1.Zcl.DataType.INT16, min: -32768, max: 32767 },
+                    { name: "reserved", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                ],
+            },
+            wiserSmartSetFipMode: {
+                name: "wiserSmartSetFipMode",
+                ID: 0xe1,
+                parameters: [
+                    { name: "zonemode", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                    { name: "fipmode", type: zigbee_herdsman_1.Zcl.DataType.ENUM8, max: 0xff },
+                    { name: "reserved", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                ],
+            },
+            wiserSmartCalibrateValve: { name: "wiserSmartCalibrateValve", ID: 0xe2, parameters: [] },
         },
-        commands: {},
         commandsResponse: {},
     }),
-    controlStatus: () => m.enumLookup({
+    controlStatus: (args) => m.enumLookup({
         name: "control_status",
         cluster: "hvacThermostat",
         attribute: "controlStatus",
@@ -651,6 +781,7 @@ const schneiderElectricExtend = {
             "Sensor Fault": 0x84,
         },
         zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
+        ...args,
     }),
     localTemperatureSourceSelect: () => m.enumLookup({
         name: "local_temperature_source_select",
@@ -716,33 +847,52 @@ const schneiderElectricExtend = {
         zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
     }),
     addWiserDeviceInfoCluster: () => m.deviceAddCustomCluster("wiserDeviceInfo", {
+        name: "wiserDeviceInfo",
         ID: 0xfe03,
         attributes: {
-            deviceInfo: { ID: 0x0020, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+            deviceInfo: { name: "deviceInfo", ID: 0x0020, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
         },
         commands: {},
         commandsResponse: {},
     }),
     addSchneiderLightSwitchConfigurationCluster: () => m.deviceAddCustomCluster("manuSpecificSchneiderLightSwitchConfiguration", {
+        name: "manuSpecificSchneiderLightSwitchConfiguration",
         ID: 0xff17,
         manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
         attributes: {
-            ledIndication: { ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
-            upSceneID: { ID: 0x0010, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            upGroupID: { ID: 0x0011, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
-            downSceneID: { ID: 0x0020, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            downGroupID: { ID: 0x0021, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
-            switchActions: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            ledIndication: { name: "ledIndication", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            upSceneID: { name: "upSceneID", ID: 0x0010, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            upGroupID: { name: "upGroupID", ID: 0x0011, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
+            downSceneID: { name: "downSceneID", ID: 0x0020, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            downGroupID: { name: "downGroupID", ID: 0x0021, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
+            switchActions: { name: "switchActions", ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
         },
         commands: {},
         commandsResponse: {},
     }),
     addSchneiderFanSwitchConfigurationCluster: () => m.deviceAddCustomCluster("manuSpecificSchneiderFanSwitchConfiguration", {
+        name: "manuSpecificSchneiderFanSwitchConfiguration",
         ID: 0xfc04,
         manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
         attributes: {
-            ledIndication: { ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
-            ledOrientation: { ID: 0x0060, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            ledIndication: { name: "ledIndication", ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            ledOrientation: { name: "ledOrientation", ID: 0x0060, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    addSchneiderLightingBallastCfgCluster: () => m.deviceAddCustomCluster("lightingBallastCfg", {
+        name: "lightingBallastCfg",
+        ID: zigbee_herdsman_1.Zcl.Clusters.lightingBallastCfg.ID,
+        attributes: {
+            wiserControlMode: {
+                name: "wiserControlMode",
+                ID: 0xe000,
+                type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+                write: true,
+                max: 0xff,
+            },
         },
         commands: {},
         commandsResponse: {},
@@ -765,8 +915,210 @@ const tzLocal = {
             return await tz.fan_mode.convertSet(entity, key, value, meta);
         },
     },
+    wiser_dimmer_mode: {
+        key: ["dimmer_mode"],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write("lightingBallastCfg", { wiserControlMode: utils.getKey(constants.wiserDimmerControlMode, value, value, Number) }, { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC });
+            return { state: { dimmer_mode: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("lightingBallastCfg", ["wiserControlMode"], {
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+            });
+        },
+    },
+    wiser_fip_setting: {
+        key: ["fip_setting"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertString(value, key);
+            const zoneLookup = { manual: 1, schedule: 2, energy_saver: 3, holiday: 6 };
+            const zonemodeNum = utils.getFromLookup(meta.state.zone_mode, zoneLookup);
+            const fipLookup = { comfort: 0, "comfort_-1": 1, "comfort_-2": 2, energy_saving: 3, frost_protection: 4, off: 5 };
+            value = value.toLowerCase();
+            utils.validateValue(value, Object.keys(fipLookup));
+            const fipmodeNum = utils.getFromLookup(value, fipLookup);
+            const payload = {
+                zonemode: zonemodeNum,
+                fipmode: fipmodeNum,
+                reserved: 0xff,
+            };
+            await entity.command("hvacThermostat", "wiserSmartSetFipMode", payload, { srcEndpoint: 11, disableDefaultResponse: true });
+            return { state: { fip_setting: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("hvacThermostat", ["wiserSmartCurrentFilPiloteMode"]);
+        },
+    },
+    wiser_hact_config: {
+        key: ["hact_config"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertString(value, key);
+            const lookup = { unconfigured: 0x00, setpoint_switch: 0x80, setpoint_fip: 0x82, fip_fip: 0x83 };
+            value = value.toLowerCase();
+            const mode = utils.getFromLookup(value, lookup);
+            await entity.write("hvacThermostat", { 57361: { value: mode, type: 0x18 } });
+            return { state: { hact_config: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("hvacThermostat", ["wiserSmartHactConfig"]);
+        },
+    },
+    wiser_zone_mode: {
+        key: ["zone_mode"],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = { manual: 1, schedule: 2, energy_saver: 3, holiday: 6 };
+            const zonemodeNum = utils.getFromLookup(value, lookup);
+            await entity.write("hvacThermostat", { 57360: { value: zonemodeNum, type: 0x30 } });
+            return { state: { zone_mode: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("hvacThermostat", ["wiserSmartZoneMode"]);
+        },
+    },
+    wiser_vact_calibrate_valve: {
+        key: ["calibrate_valve"],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.command("hvacThermostat", "wiserSmartCalibrateValve", {}, { srcEndpoint: 11, disableDefaultResponse: true });
+            return { state: { calibrate_valve: value } };
+        },
+    },
+    wiser_sed_zone_mode: {
+        key: ["zone_mode"],
+        convertSet: (entity, key, value, meta) => {
+            return { state: { zone_mode: value } };
+        },
+    },
+    wiser_sed_occupied_heating_setpoint: {
+        key: ["occupied_heating_setpoint"],
+        convertSet: (entity, key, value, meta) => {
+            utils.assertNumber(value, key);
+            utils.assertEndpoint(entity);
+            const occupiedHeatingSetpoint = Number((Math.round(Number((value * 2).toFixed(1))) / 2).toFixed(1)) * 100;
+            entity.saveClusterAttributeKeyValue("hvacThermostat", { occupiedHeatingSetpoint });
+            return { state: { occupied_heating_setpoint: value } };
+        },
+    },
+    wiser_sed_thermostat_local_temperature_calibration: {
+        key: ["local_temperature_calibration"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertNumber(value);
+            await entity.write("hvacThermostat", { localTemperatureCalibration: Math.round(value * 10) }, { srcEndpoint: 11, disableDefaultResponse: true });
+            return { state: { local_temperature_calibration: value } };
+        },
+    },
+    wiser_sed_thermostat_keypad_lockout: {
+        key: ["keypad_lockout"],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write("hvacUserInterfaceCfg", { keypadLockout: utils.getKey(constants.keypadLockoutMode, value, value, Number) }, { srcEndpoint: 11, disableDefaultResponse: true });
+            return { state: { keypad_lockout: value } };
+        },
+    },
+    cctfr6400_thermostat_system_mode: {
+        key: ["system_mode"],
+        convertSet: (entity, key, value, meta) => {
+            utils.assertEndpoint(entity);
+            const systemMode = utils.getKey(constants.thermostatSystemModes, value, undefined, Number);
+            entity.saveClusterAttributeKeyValue("hvacThermostat", { systemMode: systemMode });
+            return { state: { system_mode: value } };
+        },
+    },
+    cctfr6400_thermostat_occupied_heating_setpoint: {
+        key: ["occupied_heating_setpoint"],
+        convertSet: (entity, key, value, meta) => {
+            utils.assertNumber(value, key);
+            utils.assertEndpoint(entity);
+            const occupiedHeatingSetpoint = Number((Math.round(Number((value * 2).toFixed(1))) / 2).toFixed(1)) * 100;
+            entity.saveClusterAttributeKeyValue("hvacThermostat", { occupiedHeatingSetpoint: occupiedHeatingSetpoint });
+            return { state: { occupied_heating_setpoint: value } };
+        },
+    },
+    cctfr6400_thermostat_control_sequence_of_operation: {
+        key: ["control_sequence_of_operation"],
+        convertSet: (entity, key, value, meta) => {
+            utils.assertEndpoint(entity);
+            const val = utils.getKey(constants.thermostatControlSequenceOfOperations, value, value, Number);
+            entity.saveClusterAttributeKeyValue("hvacThermostat", { ctrlSeqeOfOper: val });
+            return { state: { control_sequence_of_operation: value } };
+        },
+    },
+    cctfr6400_thermostat_pi_heating_demand: {
+        key: ["pi_heating_demand"],
+        convertSet: (entity, key, value, meta) => {
+            utils.assertEndpoint(entity);
+            entity.saveClusterAttributeKeyValue("hvacThermostat", { pIHeatingDemand: value });
+            return { state: { pi_heating_demand: value } };
+        },
+    },
+    schneider_thermostat_keypad_lockout: {
+        key: ["keypad_lockout"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertEndpoint(entity);
+            const keypadLockout = utils.getKey(constants.keypadLockoutMode, value, value, Number);
+            await entity.write("hvacUserInterfaceCfg", { keypadLockout });
+            entity.saveClusterAttributeKeyValue("hvacUserInterfaceCfg", { keypadLockout });
+            return { state: { keypad_lockout: value } };
+        },
+    },
+    schneider_dimmer_mode: {
+        key: ["dimmer_mode"],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = { RC: 1, RL: 2 };
+            const mode = utils.getFromLookup(value, lookup);
+            await entity.write("lightingBallastCfg", { wiserControlMode: mode }, { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC });
+            return { state: { dimmer_mode: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("lightingBallastCfg", ["wiserControlMode"], {
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC,
+            });
+        },
+    },
+    cctfr6700_temperature_measured_value: {
+        key: ["temperature_measured_value"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertNumber(value);
+            utils.assertEndpoint(entity);
+            await entity.report("msTemperatureMeasurement", { measuredValue: Math.round(value * 100) });
+        },
+    },
 };
 const fzLocal = {
+    schneider_ui_action: {
+        cluster: "wiserDeviceInfo",
+        type: "attributeReport",
+        convert: (model, msg, publish, options, meta) => {
+            if (utils.hasAlreadyProcessedMessage(msg, model))
+                return;
+            const data = msg.data.deviceInfo.split(",");
+            if (data[0] === "UI" && data[1]) {
+                const result = { action: utils.toSnakeCase(data[1]) };
+                let screenAwake = globalStore.getValue(msg.endpoint, "screenAwake");
+                screenAwake = screenAwake !== undefined ? screenAwake : false;
+                const keypadLockedNumber = Number(msg.endpoint.getClusterAttributeValue("hvacUserInterfaceCfg", "keypadLockout"));
+                const keypadLocked = keypadLockedNumber !== undefined ? keypadLockedNumber !== 0 : false;
+                // Emulate UI temperature update
+                if (data[1] === "ScreenWake") {
+                    globalStore.putValue(msg.endpoint, "screenAwake", true);
+                }
+                else if (data[1] === "ScreenSleep") {
+                    globalStore.putValue(msg.endpoint, "screenAwake", false);
+                }
+                else if (screenAwake && !keypadLocked) {
+                    let occupiedHeatingSetpoint = Number(msg.endpoint.getClusterAttributeValue("hvacThermostat", "occupiedHeatingSetpoint"));
+                    occupiedHeatingSetpoint = occupiedHeatingSetpoint != null ? occupiedHeatingSetpoint : 400;
+                    if (data[1] === "ButtonPressMinusDown") {
+                        occupiedHeatingSetpoint -= 50;
+                    }
+                    else if (data[1] === "ButtonPressPlusDown") {
+                        occupiedHeatingSetpoint += 50;
+                    }
+                    msg.endpoint.saveClusterAttributeKeyValue("hvacThermostat", { occupiedHeatingSetpoint: occupiedHeatingSetpoint });
+                    result.occupied_heating_setpoint = occupiedHeatingSetpoint / 100;
+                }
+                return result;
+            }
+        },
+    },
     schneider_powertag: {
         cluster: "greenPower",
         type: ["commandNotification", "commandCommissioningNotification"],
@@ -775,17 +1127,24 @@ const fzLocal = {
                 return;
             }
             const commandID = msg.data.commandID;
-            if (utils.hasAlreadyProcessedMessage(msg, model, msg.data.frameCounter, `${msg.device.ieeeAddr}_${commandID}`))
+            if (utils.hasAlreadyProcessedMessage(msg, model, msg.data.frameCounter, `${msg.device.ieeeAddr}_${commandID}`)) {
                 return;
+            }
+            if (commandID >= 0xe0)
+                return; // Skip op commands
             const rxAfterTx = msg.data.options & (1 << 11);
             const ret = {};
             switch (commandID) {
+                case 0xa0: {
+                    // Should handle this cluster as well
+                    // const cmd = msg.data.commandFrame as GpdAttributeReport;
+                    break;
+                }
                 case 0xa1: {
-                    const attr = msg.data.commandFrame.attributes;
-                    const clusterID = msg.data.commandFrame.clusterID;
-                    switch (clusterID) {
-                        case 2820: {
-                            // haElectricalMeasurement
+                    const cmd = msg.data.commandFrame;
+                    switch (cmd.clusterID) {
+                        case zigbee_herdsman_1.Zcl.Clusters.haElectricalMeasurement.ID: {
+                            const attr = cmd.attributes;
                             const acCurrentDivisor = attr.acCurrentDivisor;
                             const acVoltageDivisor = attr.acVoltageDivisor;
                             const acFrequencyDivisor = attr.acFrequencyDivisor;
@@ -837,24 +1196,21 @@ const fzLocal = {
                             }
                             break;
                         }
-                        case 1794: {
-                            // seMetering
+                        case zigbee_herdsman_1.Zcl.Clusters.seMetering.ID: {
+                            const attr = cmd.attributes;
                             const divisor = attr.divisor;
                             if (attr.currentSummDelivered !== undefined) {
                                 const val = attr.currentSummDelivered;
                                 ret.energy = val / divisor;
                             }
                             if (attr["16652"] !== undefined) {
-                                const val = attr["16652"];
-                                ret.energy_phase_a = val / divisor;
+                                ret.energy_phase_a = attr["16652"] / divisor;
                             }
                             if (attr["16908"] !== undefined) {
-                                const val = attr["16908"];
-                                ret.energy_phase_b = val / divisor;
+                                ret.energy_phase_b = attr["16908"] / divisor;
                             }
                             if (attr["17164"] !== undefined) {
-                                const val = attr["17164"];
-                                ret.energy_phase_c = val / divisor;
+                                ret.energy_phase_c = attr["17164"] / divisor;
                             }
                             if (attr.powerFactor !== undefined) {
                                 ret.power_factor = attr.powerFactor;
@@ -864,9 +1220,11 @@ const fzLocal = {
                     }
                     break;
                 }
-                case 0xa3:
+                case 0xa3: {
                     // Should handle this cluster as well
+                    // const cmd = msg.data.commandFrame as GpdManufMultiClusterAttributeReport;
                     break;
+                }
             }
             if (rxAfterTx) {
                 // Send Schneider specific ACK to make PowerTag happy
@@ -930,6 +1288,158 @@ const fzLocal = {
             return result;
         },
     },
+    wiser_lighting_ballast_configuration: {
+        cluster: "lightingBallastCfg",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = fz.lighting_ballast_configuration.convert(model, msg, publish, options, meta);
+            if (result && msg.data.wiserControlMode !== undefined) {
+                result.dimmer_mode = constants.wiserDimmerControlMode[msg.data.wiserControlMode];
+            }
+            return result;
+        },
+    },
+    wiser_smart_setpoint_command_client: {
+        cluster: "hvacThermostat",
+        type: ["commandWiserSmartSetSetpoint"],
+        convert: (model, msg, publish, options, meta) => {
+            const attribute = {};
+            const result = {};
+            // The UI client on the thermostat also updates the server, so no need to readback/send again on next sync.
+            // This also ensures the next client read of setpoint is in sync with the latest commanded value.
+            attribute.occupiedHeatingSetpoint = msg.data.setpoint;
+            msg.endpoint.saveClusterAttributeKeyValue("hvacThermostat", attribute);
+            result.occupied_heating_setpoint = msg.data.setpoint / 100.0;
+            logger_1.logger.debug(`received wiser setpoint command with value: '${msg.data.setpoint}'`, NS);
+            return result;
+        },
+    },
+    wiser_smart_thermostat: {
+        cluster: "hvacThermostat",
+        type: ["attributeReport", "readResponse"],
+        convert: async (model, msg, publish, options, meta) => {
+            const result = fz.thermostat.convert(model, msg, publish, options, meta);
+            if (result) {
+                if (msg.data.wiserSmartZoneMode !== undefined) {
+                    const lookup = { 1: "manual", 2: "schedule", 3: "energy_saver", 6: "holiday" };
+                    result.zone_mode = lookup[msg.data.wiserSmartZoneMode];
+                }
+                if (msg.data.wiserSmartHactConfig !== undefined) {
+                    const lookup = { 0: "unconfigured", 128: "setpoint_switch", 130: "setpoint_fip", 131: "fip_fip" };
+                    result.hact_config = lookup[msg.data.wiserSmartHactConfig];
+                }
+                if (msg.data.wiserSmartCurrentFilPiloteMode !== undefined) {
+                    const lookup = {
+                        0: "comfort",
+                        1: "comfort_-1",
+                        2: "comfort_-2",
+                        3: "energy_saving",
+                        4: "frost_protection",
+                        5: "off",
+                    };
+                    result.fip_setting = lookup[msg.data.wiserSmartCurrentFilPiloteMode];
+                }
+                if (msg.data.wiserSmartValvePosition !== undefined) {
+                    result.pi_heating_demand = msg.data.wiserSmartValvePosition;
+                }
+                if (msg.data.wiserSmartValveCalibrationStatus !== undefined) {
+                    const lookup = {
+                        0: "ongoing",
+                        1: "successful",
+                        2: "uncalibrated",
+                        3: "failed_e1",
+                        4: "failed_e2",
+                        5: "failed_e3",
+                    };
+                    result.valve_calibration_status = lookup[msg.data.wiserSmartValveCalibrationStatus];
+                }
+                // Radiator thermostats command changes from UI, but report value periodically for sync,
+                // force an update of the value if it doesn't match the current existing value
+                if (meta.device.modelID === "EH-ZB-VACT" &&
+                    msg.data.occupiedHeatingSetpoint !== undefined &&
+                    meta.state.occupied_heating_setpoint !== undefined) {
+                    if (result.occupied_heating_setpoint !== meta.state.occupied_heating_setpoint) {
+                        const lookup = { manual: 1, schedule: 2, energy_saver: 3, holiday: 6 };
+                        const zonemodeNum = lookup[Number(meta.state.zone_mode)];
+                        const setpoint = Number((Math.round(Number((Number(meta.state.occupied_heating_setpoint) * 2).toFixed(1))) / 2).toFixed(1)) * 100;
+                        const payload = {
+                            operatingmode: 0,
+                            zonemode: zonemodeNum,
+                            setpoint: setpoint,
+                            reserved: 0xff,
+                        };
+                        await msg.endpoint.command("hvacThermostat", "wiserSmartSetSetpoint", payload, {
+                            srcEndpoint: 11,
+                            disableDefaultResponse: true,
+                        });
+                        logger_1.logger.debug(`syncing vact setpoint was: '${result.occupied_heating_setpoint}' now: '${meta.state.occupied_heating_setpoint}'`, NS);
+                    }
+                }
+                else {
+                    publish(result);
+                }
+            }
+        },
+    },
+    wiser_smart_thermostat_client: {
+        cluster: "hvacThermostat",
+        type: "read",
+        convert: async (model, msg, publish, options, meta) => {
+            const response = {};
+            if (msg.data.includes("wiserSmartZoneMode") || msg.data.includes(0xe010)) {
+                // Zone Mode
+                const lookup = { manual: 1, schedule: 2, energy_saver: 3, holiday: 6 };
+                const zonemodeNum = meta.state.zone_mode ? lookup[meta.state.zone_mode] : 1;
+                response.wiserSmartZoneMode = { value: zonemodeNum };
+                await msg.endpoint.readResponse(msg.cluster, msg.meta.zclTransactionSequenceNumber, response, { srcEndpoint: 11 });
+            }
+        },
+    },
+    thermostat_running_state_from_piheat: {
+        cluster: "hvacThermostat",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = fz.thermostat.convert(model, msg, publish, options, meta);
+            if (result && msg.data.pIHeatingDemand !== undefined) {
+                result.running_state = msg.data.pIHeatingDemand >= 10 ? "heat" : "idle";
+            }
+            return result;
+        },
+    },
+    schneider_temperature: {
+        cluster: "msTemperatureMeasurement",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const temperature = msg.data.measuredValue / 100.0;
+            const property = (0, utils_1.postfixWithEndpointName)("local_temperature", msg, model, meta);
+            return { [property]: temperature };
+        },
+    },
+    schneider_lighting_ballast_configuration: {
+        cluster: "lightingBallastCfg",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = fz.lighting_ballast_configuration.convert(model, msg, publish, options, meta);
+            const lookup = { 1: "RC", 2: "RL" };
+            if (result && msg.data.wiserControlMode !== undefined) {
+                result.dimmer_mode = lookup[msg.data.wiserControlMode];
+            }
+            return result;
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    EKO09738_metering: {
+        // Elko EKO09738 and EKO09716 reports power in mW, scale to W
+        cluster: "seMetering",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = fz.metering.convert(model, msg, publish, options, meta);
+            if (result && result.power !== undefined) {
+                result.power /= 1000;
+            }
+            return result;
+        },
+    },
 };
 exports.definitions = [
     {
@@ -989,10 +1499,10 @@ exports.definitions = [
         model: "WV704R0A0902",
         vendor: "Schneider Electric",
         description: "Wiser radiator thermostat",
+        extend: [schneiderElectricExtend.addWiserDeviceInfoCluster()],
         fromZigbee: [fz.ignore_haDiagnostic, fz.thermostat, fz.battery, fz.hvac_user_interface, fzLocal.wiser_device_info],
         toZigbee: [tz.thermostat_occupied_heating_setpoint, tz.thermostat_keypad_lockout],
         meta: { battery: { voltageToPercentage: { min: 2500, max: 3200 } } },
-        extend: [schneiderElectricExtend.addWiserDeviceInfoCluster()],
         exposes: [
             e
                 .climate()
@@ -1036,9 +1546,12 @@ exports.definitions = [
         vendor: "Schneider Electric",
         description: "Micro module dimmer",
         ota: true,
-        extend: [m.light({ powerOnBehavior: false, configureReporting: true, levelConfig: {} })],
-        fromZigbee: [fz.wiser_lighting_ballast_configuration],
-        toZigbee: [tz.ballast_config, tz.wiser_dimmer_mode],
+        extend: [
+            schneiderElectricExtend.addSchneiderLightingBallastCfgCluster(),
+            m.light({ powerOnBehavior: false, configureReporting: true, levelConfig: {} }),
+        ],
+        fromZigbee: [fzLocal.wiser_lighting_ballast_configuration],
+        toZigbee: [tz.ballast_config, tzLocal.wiser_dimmer_mode],
         exposes: [
             e
                 .numeric("ballast_minimum_level", ea.ALL)
@@ -1074,9 +1587,9 @@ exports.definitions = [
         vendor: "Schneider Electric",
         description: "Micro module dimmer with neutral lead",
         ota: true,
-        extend: [m.light({ configureReporting: true, levelConfig: {} })],
-        fromZigbee: [fz.wiser_lighting_ballast_configuration],
-        toZigbee: [tz.ballast_config, tz.wiser_dimmer_mode],
+        extend: [schneiderElectricExtend.addSchneiderLightingBallastCfgCluster(), m.light({ configureReporting: true, levelConfig: {} })],
+        fromZigbee: [fzLocal.wiser_lighting_ballast_configuration],
+        toZigbee: [tz.ballast_config, tzLocal.wiser_dimmer_mode],
         exposes: [
             e
                 .numeric("ballast_minimum_level", ea.ALL)
@@ -1106,8 +1619,9 @@ exports.definitions = [
         model: "WDE002334",
         vendor: "Schneider Electric",
         description: "Rotary dimmer",
-        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fz.wiser_lighting_ballast_configuration],
-        toZigbee: [tz.light_onoff_brightness, tz.level_config, tz.ballast_config, tz.wiser_dimmer_mode],
+        extend: [schneiderElectricExtend.addSchneiderLightingBallastCfgCluster()],
+        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fzLocal.wiser_lighting_ballast_configuration],
+        toZigbee: [tz.light_onoff_brightness, tz.level_config, tz.ballast_config, tzLocal.wiser_dimmer_mode],
         exposes: [
             e.light_brightness().withLevelConfig(),
             e
@@ -1163,8 +1677,9 @@ exports.definitions = [
         model: "WDE002960",
         vendor: "Schneider Electric",
         description: "Push button dimmer",
-        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fz.wiser_lighting_ballast_configuration],
-        toZigbee: [tz.light_onoff_brightness, tz.level_config, tz.ballast_config, tz.wiser_dimmer_mode],
+        extend: [schneiderElectricExtend.addSchneiderLightingBallastCfgCluster()],
+        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fzLocal.wiser_lighting_ballast_configuration],
+        toZigbee: [tz.light_onoff_brightness, tz.level_config, tz.ballast_config, tzLocal.wiser_dimmer_mode],
         exposes: [
             e.light_brightness().withLevelConfig(),
             e
@@ -1319,24 +1834,16 @@ exports.definitions = [
         model: "CCT711119",
         vendor: "Schneider Electric",
         description: "Wiser smart plug",
-        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.power_on_behavior],
-        toZigbee: [tz.on_off, tz.power_on_behavior, tz.electrical_measurement_power],
-        exposes: [
-            e.switch(),
-            e.power().withAccess(ea.STATE_GET),
-            e.energy(),
-            e.enum("power_on_behavior", ea.ALL, ["off", "previous", "on"]).withDescription("Controls the behaviour when the device is powered on"),
+        version: "0.0.1",
+        extend: [
+            m.onOff(),
+            m.electricityMeter({
+                power: { min: 5, change: 1 },
+                energy: { min: "1_MINUTE", change: 1 },
+                voltage: false,
+                current: false,
+            }),
         ],
-        configure: async (device, coordinatorEndpoint) => {
-            const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "haElectricalMeasurement", "seMetering"]);
-            await reporting.onOff(endpoint);
-            // only activePower seems to be support, although compliance document states otherwise
-            await endpoint.read("haElectricalMeasurement", ["acPowerMultiplier", "acPowerDivisor"]);
-            await reporting.activePower(endpoint);
-            await reporting.readMeteringMultiplierDivisor(endpoint);
-            await reporting.currentSummDelivered(endpoint, { min: 60, change: 1 });
-        },
     },
     {
         zigbeeModel: ["U201DST600ZB"],
@@ -1357,9 +1864,9 @@ exports.definitions = [
         model: "CCTFR6100Z3",
         vendor: "Schneider Electric",
         description: "Wiser radiator thermostat",
+        extend: [schneiderElectricExtend.addWiserDeviceInfoCluster()],
         fromZigbee: [fz.ignore_haDiagnostic, fz.thermostat, fz.battery, fz.hvac_user_interface, fzLocal.wiser_device_info],
         toZigbee: [tz.thermostat_occupied_heating_setpoint, tz.thermostat_keypad_lockout],
-        extend: [schneiderElectricExtend.addWiserDeviceInfoCluster()],
         exposes: [
             e
                 .climate()
@@ -1424,8 +1931,8 @@ exports.definitions = [
         model: "MEG5116-0300/MEG5171-0000",
         vendor: "Schneider Electric",
         description: "Merten MEG5171 PlusLink Dimmer insert with Merten Wiser System M Push Button (1fold)",
-        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fz.wiser_lighting_ballast_configuration],
-        toZigbee: [tz.light_onoff_brightness, tz.level_config, tz.ballast_config, tz.wiser_dimmer_mode],
+        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fzLocal.wiser_lighting_ballast_configuration],
+        toZigbee: [tz.light_onoff_brightness, tz.level_config, tz.ballast_config, tzLocal.wiser_dimmer_mode],
         exposes: [
             e.light_brightness().withLevelConfig(),
             e
@@ -1442,7 +1949,12 @@ exports.definitions = [
                 .enum("dimmer_mode", ea.ALL, ["auto", "rc", "rl", "rl_led"])
                 .withDescription("Sets dimming mode to autodetect or fixed RC/RL/RL_LED mode (max load is reduced in RL_LED)"),
         ],
-        extend: [schneiderElectricExtend.addSchneiderLightSwitchConfigurationCluster(), indicatorMode(), switchActions()],
+        extend: [
+            schneiderElectricExtend.addSchneiderLightingBallastCfgCluster(),
+            schneiderElectricExtend.addSchneiderLightSwitchConfigurationCluster(),
+            indicatorMode(),
+            switchActions(),
+        ],
         configure: async (device, coordinatorEndpoint) => {
             const endpoint = device.getEndpoint(3);
             await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "genLevelCtrl", "lightingBallastCfg"]);
@@ -1455,8 +1967,8 @@ exports.definitions = [
         model: "MEG5126-0300/MEG5171-0000",
         vendor: "Schneider Electric",
         description: "Merten MEG5171 PlusLink Dimmer insert with Merten Wiser System M Push Button (2fold)",
-        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fz.wiser_lighting_ballast_configuration],
-        toZigbee: [tz.light_onoff_brightness, tz.level_config, tz.ballast_config, tz.wiser_dimmer_mode],
+        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fzLocal.wiser_lighting_ballast_configuration],
+        toZigbee: [tz.light_onoff_brightness, tz.level_config, tz.ballast_config, tzLocal.wiser_dimmer_mode],
         exposes: [
             e.light_brightness().withLevelConfig(),
             e
@@ -1474,6 +1986,7 @@ exports.definitions = [
                 .withDescription("Sets dimming mode to autodetect or fixed RC/RL/RL_LED mode (max load is reduced in RL_LED)"),
         ],
         extend: [
+            schneiderElectricExtend.addSchneiderLightingBallastCfgCluster(),
             schneiderElectricExtend.addSchneiderLightSwitchConfigurationCluster(),
             indicatorMode("right"),
             indicatorMode("left"),
@@ -1496,8 +2009,8 @@ exports.definitions = [
         model: "MEG5126-0300/MEG5172-0000",
         vendor: "Schneider Electric",
         description: "Merten MEG5172 PlusLink Dimmer insert with Merten Wiser System M Push Button (2fold)",
-        fromZigbee: [fz.wiser_lighting_ballast_configuration],
-        toZigbee: [tz.ballast_config, tz.wiser_dimmer_mode],
+        fromZigbee: [fzLocal.wiser_lighting_ballast_configuration],
+        toZigbee: [tz.ballast_config, tzLocal.wiser_dimmer_mode],
         exposes: [
             e
                 .numeric("ballast_minimum_level", ea.ALL)
@@ -1514,9 +2027,10 @@ exports.definitions = [
                 .withDescription("Sets dimming mode to autodetect or fixed RC/RL/RL_LED mode (max load is reduced in RL_LED)"),
         ],
         extend: [
+            schneiderElectricExtend.addSchneiderLightingBallastCfgCluster(),
+            schneiderElectricExtend.addSchneiderLightSwitchConfigurationCluster(),
             m.deviceEndpoints({ endpoints: { left: 4, right: 3, left_btn: 22, right_btn: 21 } }),
             m.light({ endpointNames: ["left", "right"], configureReporting: true }),
-            schneiderElectricExtend.addSchneiderLightSwitchConfigurationCluster(),
             switchActions("left_btn"),
             switchActions("right_btn"),
             indicatorMode("left_btn"),
@@ -1568,8 +2082,15 @@ exports.definitions = [
         model: "545D6102",
         vendor: "Schneider Electric",
         description: "LK FUGA wiser wireless dimmer",
-        fromZigbee: [fz.schneider_lighting_ballast_configuration, fz.command_recall, fz.command_on, fz.command_off, fz.command_move, fz.command_stop],
-        toZigbee: [tz.ballast_config, tz.schneider_dimmer_mode],
+        fromZigbee: [
+            fzLocal.schneider_lighting_ballast_configuration,
+            fz.command_recall,
+            fz.command_on,
+            fz.command_off,
+            fz.command_move,
+            fz.command_stop,
+        ],
+        toZigbee: [tz.ballast_config, tzLocal.schneider_dimmer_mode],
         endpoint: (device) => {
             return { l1: 3, s1: 21, s2: 22, s3: 23, s4: 24 };
         },
@@ -1577,6 +2098,7 @@ exports.definitions = [
         extend: [
             m.light({ endpointNames: ["l1"], configureReporting: true, levelConfig: {} }),
             schneiderElectricExtend.addSchneiderLightSwitchConfigurationCluster(),
+            schneiderElectricExtend.addSchneiderLightingBallastCfgCluster(),
             indicatorMode("s1"),
             indicatorMode("s2"),
             indicatorMode("s3"),
@@ -1681,13 +2203,12 @@ exports.definitions = [
         whiteLabel: [{ model: "CCTFR6710", fingerprint: [{ modelID: "CCTFR6710" }] }],
         fromZigbee: [fz.thermostat, fz.metering],
         toZigbee: [
-            tz.schneider_temperature_measured_value,
+            tzLocal.cctfr6700_temperature_measured_value,
             tz.thermostat_system_mode,
             tz.thermostat_running_state,
             tz.thermostat_local_temperature,
             tz.thermostat_occupied_heating_setpoint,
             tz.thermostat_control_sequence_of_operation,
-            tz.schneider_temperature_measured_value,
         ],
         extend: [schneiderElectricExtend.addHeatingCoolingOutputClusterServer(), schneiderElectricExtend.pilotMode()],
         exposes: [
@@ -1716,13 +2237,14 @@ exports.definitions = [
         model: "CCTFR6400",
         vendor: "Schneider Electric",
         description: "Temperature/Humidity measurement with thermostat interface",
-        fromZigbee: [fz.battery, fz.schneider_temperature, fz.humidity, fz.thermostat, fz.schneider_ui_action],
+        extend: [schneiderElectricExtend.customThermostatCluster()],
+        fromZigbee: [fz.battery, fzLocal.schneider_temperature, fz.humidity, fz.thermostat, fzLocal.schneider_ui_action],
         toZigbee: [
-            tz.schneider_thermostat_system_mode,
-            tz.schneider_thermostat_occupied_heating_setpoint,
-            tz.schneider_thermostat_control_sequence_of_operation,
-            tz.schneider_thermostat_pi_heating_demand,
-            tz.schneider_thermostat_keypad_lockout,
+            tzLocal.cctfr6400_thermostat_system_mode,
+            tzLocal.cctfr6400_thermostat_occupied_heating_setpoint,
+            tzLocal.cctfr6400_thermostat_control_sequence_of_operation,
+            tzLocal.cctfr6400_thermostat_pi_heating_demand,
+            tzLocal.schneider_thermostat_keypad_lockout,
         ],
         exposes: [
             e.keypad_lockout().withAccess(ea.STATE_SET),
@@ -1790,19 +2312,20 @@ exports.definitions = [
         model: "EER53000",
         vendor: "Schneider Electric",
         description: "Wiser radiator thermostat (VACT)",
+        extend: [schneiderElectricExtend.customThermostatCluster()],
         fromZigbee: [
             fz.battery,
             fz.hvac_user_interface,
-            fz.wiser_smart_thermostat,
-            fz.wiser_smart_thermostat_client,
-            fz.wiser_smart_setpoint_command_client,
+            fzLocal.wiser_smart_thermostat,
+            fzLocal.wiser_smart_thermostat_client,
+            fzLocal.wiser_smart_setpoint_command_client,
         ],
         toZigbee: [
-            tz.wiser_sed_thermostat_local_temperature_calibration,
-            tz.wiser_sed_occupied_heating_setpoint,
-            tz.wiser_sed_thermostat_keypad_lockout,
-            tz.wiser_vact_calibrate_valve,
-            tz.wiser_sed_zone_mode,
+            tzLocal.wiser_sed_thermostat_local_temperature_calibration,
+            tzLocal.wiser_sed_occupied_heating_setpoint,
+            tzLocal.wiser_sed_thermostat_keypad_lockout,
+            tzLocal.wiser_vact_calibrate_valve,
+            tzLocal.wiser_sed_zone_mode,
         ],
         exposes: [
             e.battery(),
@@ -1847,14 +2370,15 @@ exports.definitions = [
         model: "EER51000",
         vendor: "Schneider Electric",
         description: "Wiser thermostat (RTS)",
+        extend: [schneiderElectricExtend.customThermostatCluster()],
         fromZigbee: [
             fz.battery,
             fz.hvac_user_interface,
-            fz.wiser_smart_thermostat_client,
-            fz.wiser_smart_setpoint_command_client,
-            fz.schneider_temperature,
+            fzLocal.wiser_smart_thermostat_client,
+            fzLocal.wiser_smart_setpoint_command_client,
+            fzLocal.schneider_temperature,
         ],
-        toZigbee: [tz.wiser_sed_zone_mode, tz.wiser_sed_occupied_heating_setpoint],
+        toZigbee: [tzLocal.wiser_sed_zone_mode, tzLocal.wiser_sed_occupied_heating_setpoint],
         exposes: [
             e.battery(),
             e.climate().withSetpoint("occupied_heating_setpoint", 7, 30, 0.5, ea.STATE_SET).withLocalTemperature(ea.STATE),
@@ -1898,13 +2422,14 @@ exports.definitions = [
         model: "EER50000",
         vendor: "Schneider Electric",
         description: "Wiser H-Relay (HACT)",
-        fromZigbee: [fz.wiser_smart_thermostat, fz.metering, fz.identify],
+        extend: [schneiderElectricExtend.customThermostatCluster()],
+        fromZigbee: [fzLocal.wiser_smart_thermostat, fz.metering, fz.identify],
         toZigbee: [
             tz.thermostat_local_temperature,
             tz.thermostat_occupied_heating_setpoint,
-            tz.wiser_fip_setting,
-            tz.wiser_hact_config,
-            tz.wiser_zone_mode,
+            tzLocal.wiser_fip_setting,
+            tzLocal.wiser_hact_config,
+            tzLocal.wiser_zone_mode,
             tz.identify,
         ],
         exposes: [
@@ -1949,7 +2474,7 @@ exports.definitions = [
         model: "EKO09738",
         vendor: "Schneider Electric",
         description: "Zigbee smart socket with power meter",
-        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.EKO09738_metering, fz.power_on_behavior],
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fzLocal.EKO09738_metering, fz.power_on_behavior],
         toZigbee: [tz.on_off, tz.power_on_behavior],
         exposes: [
             e.switch(),
@@ -1974,7 +2499,7 @@ exports.definitions = [
         model: "EKO09716",
         vendor: "Schneider Electric",
         description: "Zigbee smart socket with power meter",
-        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.EKO09738_metering, fz.power_on_behavior],
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fzLocal.EKO09738_metering, fz.power_on_behavior],
         toZigbee: [tz.on_off, tz.power_on_behavior],
         exposes: [
             e.switch(),
@@ -1999,7 +2524,7 @@ exports.definitions = [
         model: "545D6115",
         vendor: "Schneider Electric",
         description: "LK FUGA wiser wireless socket outlet",
-        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.EKO09738_metering, fz.power_on_behavior],
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fzLocal.EKO09738_metering, fz.power_on_behavior],
         toZigbee: [tz.on_off, tz.power_on_behavior],
         extend: [schneiderElectricExtend.addSchneiderFanSwitchConfigurationCluster(), socketIndicatorMode()],
         exposes: [
@@ -2067,16 +2592,20 @@ exports.definitions = [
         model: "CCT595011",
         vendor: "Schneider Electric",
         description: "Wiser motion sensor",
-        fromZigbee: [fz.battery, fz.ias_enroll, fz.ias_occupancy_only_alarm_2],
-        toZigbee: [],
-        configure: async (device, coordinatorEndpoint) => {
-            const endpoint = device.getEndpoint(1);
-            const binds = ["genPowerCfg"];
-            await reporting.bind(endpoint, coordinatorEndpoint, binds);
-            await reporting.batteryPercentageRemaining(endpoint);
-        },
-        exposes: [e.battery(), e.occupancy()],
-        extend: [m.illuminance()],
+        version: "0.0.1",
+        extend: [
+            m.battery(),
+            m.iasZoneAlarm({ zoneType: "occupancy", zoneAttributes: ["alarm_2", "battery_low"] }),
+            m.illuminance(),
+            m.enumLookup({
+                name: "sensitivity_level",
+                description: "Sensitivity level for the occupancy sensor",
+                attribute: "currentZoneSensitivityLevel",
+                cluster: "ssIasZone",
+                lookup: { low: 0x00, medium: 0x01, high: 0x02 },
+                entityCategory: "config",
+            }),
+        ],
     },
     {
         zigbeeModel: ["CH/Socket/2"],
@@ -2176,7 +2705,7 @@ exports.definitions = [
         vendor: "Schneider Electric",
         description: "Smart thermostat",
         extend: [
-            schneiderElectricExtend.thermostatWithPower({
+            m.thermostat({
                 localTemperature: {
                     values: {
                         description: "The temperature measured by the selected sensor (see 'Local temperature source select', Ambient or External).",
@@ -2187,10 +2716,16 @@ exports.definitions = [
                     maxHeatSetpointLimit: { min: 4, max: 40, step: 0.5 },
                     minHeatSetpointLimit: { min: 4, max: 40, step: 0.5 },
                 },
+                runningState: {
+                    values: ["idle", "heat"],
+                    toZigbee: { skip: true },
+                    configure: { skip: true },
+                },
                 systemMode: { values: ["off", "heat"] },
-                piHeatingDemand: { values: true },
+                piHeatingDemand: { values: true, dontMapPIHeatingDemand: true },
                 ctrlSeqeOfOper: { values: ["cooling_only", "heating_only"] },
             }),
+            schneiderElectricExtend.runningStateFromPower(),
             m.electricityMeter({
                 cluster: "metering",
                 voltage: false,
@@ -2211,52 +2746,19 @@ exports.definitions = [
             schneiderElectricExtend.thermostatApplication(),
             schneiderElectricExtend.heatingEmitter(),
             schneiderElectricExtend.addHeatingCoolingOutputClusterServer(),
-            m.enumLookup({
-                name: "heating_output_mode",
-                cluster: "heatingCoolingOutputClusterServer",
-                attribute: "heatingOutputMode",
+            schneiderElectricExtend.heatingOutputMode({
                 description: "On devices with alternate heating output types, this selects which should be used to control the heating unit. This attribute is (mistakenly) also called pilot_mode on some devices.",
-                entityCategory: "config",
-                access: "ALL",
                 lookup: { Disabled: 0, Relay: 1 },
             }),
             schneiderElectricExtend.customTemperatureMeasurementCluster(),
             m.deviceEndpoints({
                 endpoints: { floor: 3 },
             }),
-            m.numeric({
-                name: "temperature_sensor_correction",
-                cluster: "msTemperatureMeasurement",
-                attribute: "sensorCorrection",
-                description: "This is a user correction, possibly negative, to be added to the temperature measured by the sensor.",
-                unit: "°C",
-                scale: 100,
-                valueMin: -9,
-                valueMax: 9,
-                valueStep: 0.01,
+            schneiderElectricExtend.sensorCorrection({
                 endpointNames: ["floor"],
-                access: "ALL",
-                entityCategory: "config",
-                zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
             }),
-            m.enumLookup({
-                name: "temperature_sensor_type",
-                cluster: "msTemperatureMeasurement",
-                attribute: "temperatureSensorType",
-                description: "This is used to specify the type of temperature sensor connected to this input",
-                entityCategory: "config",
-                access: "ALL",
+            schneiderElectricExtend.temperatureSensorType({
                 endpointName: "floor",
-                lookup: {
-                    "2kΩ sensor from HRT/Alre": 1,
-                    "10kΩ sensor from B+J": 2,
-                    "12kΩ sensor from OJ": 3,
-                    "15kΩ sensor from DEVI": 4,
-                    "33kΩ sensor from EBERLE": 5,
-                    "47kΩ sensor from CTM": 6,
-                    "No sensor": 0xff,
-                },
-                zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SCHNEIDER_ELECTRIC },
             }),
             m.enumLookup({
                 name: "temperature_display_mode",
@@ -2284,59 +2786,96 @@ exports.definitions = [
         model: "WDE002497",
         vendor: "Schneider Electric",
         description: "Smart thermostat",
-        fromZigbee: [fz.stelpro_thermostat, fz.metering, fzLocal.wiser_device_info, fz.hvac_user_interface, fz.temperature],
-        toZigbee: [
-            tz.thermostat_occupied_heating_setpoint,
-            tz.thermostat_system_mode,
-            tz.thermostat_running_state,
-            tz.thermostat_local_temperature,
-            tz.thermostat_control_sequence_of_operation,
-            tz.schneider_thermostat_keypad_lockout,
-            tz.thermostat_temperature_display_mode,
-        ],
         extend: [
-            schneiderElectricExtend.addWiserDeviceInfoCluster(),
+            m.thermostat({
+                localTemperature: {
+                    values: {
+                        description: "The temperature measured by the selected sensor (see 'Local temperature source select', Ambient or External).",
+                    },
+                },
+                setpoints: { values: { occupiedHeatingSetpoint: { min: 4, max: 40, step: 0.5 } } },
+                setpointsLimit: {
+                    maxHeatSetpointLimit: { min: 4, max: 40, step: 0.5 },
+                    minHeatSetpointLimit: { min: 4, max: 40, step: 0.5 },
+                },
+                runningState: {
+                    values: ["idle", "heat"],
+                    toZigbee: { skip: true },
+                    configure: { skip: true },
+                },
+                systemMode: { values: ["off", "heat"] },
+                piHeatingDemand: { values: true },
+                ctrlSeqeOfOper: { values: ["cooling_only", "heating_only"] },
+            }),
+            schneiderElectricExtend.runningStateFromPower(),
+            m.electricityMeter({
+                cluster: "metering",
+                voltage: false,
+                current: false,
+                configureReporting: true,
+                energy: { divisor: 1000, multiplier: 1 },
+            }),
+            schneiderElectricExtend.customMeteringCluster(),
+            schneiderElectricExtend.fixedLoadDemand(),
+            schneiderElectricExtend.addHvacUserInterfaceCfgCustomAttributes(),
+            schneiderElectricExtend.displayBrightnessActive(),
+            schneiderElectricExtend.displayBrightnessInactive(),
+            schneiderElectricExtend.displayActiveTimeout(),
+            schneiderElectricExtend.customThermostatCluster(),
+            schneiderElectricExtend.localTemperatureSourceSelect(),
+            schneiderElectricExtend.controlType(),
+            schneiderElectricExtend.controlStatus(),
+            schneiderElectricExtend.thermostatApplication(),
+            schneiderElectricExtend.heatingEmitter(),
             schneiderElectricExtend.addHeatingCoolingOutputClusterServer(),
-            schneiderElectricExtend.pilotMode(),
-        ],
-        exposes: [
-            e.binary("keypad_lockout", ea.STATE_SET, "lock1", "unlock").withDescription("Enables/disables physical input on the device"),
-            e
-                .enum("temperature_display_mode", ea.ALL, ["celsius", "fahrenheit"])
-                .withDescription("The temperature format displayed on the thermostat screen"),
-            e
-                .climate()
-                .withSetpoint("occupied_heating_setpoint", 4, 30, 0.5)
-                .withLocalTemperature()
-                .withSystemMode(["off", "heat"])
-                .withRunningState(["idle", "heat"])
-                .withPiHeatingDemand(),
-            e.temperature(),
+            schneiderElectricExtend.heatingOutputMode({
+                description: "On devices with alternate heating output types, this selects which should be used to control the heating unit. This attribute is (mistakenly) also called pilot_mode on some devices.",
+                lookup: { Disabled: 0, Relay: 1 },
+            }),
+            schneiderElectricExtend.customTemperatureMeasurementCluster(),
+            m.deviceEndpoints({
+                endpoints: { floor: 3 },
+            }),
+            schneiderElectricExtend.sensorCorrection({
+                endpointNames: ["floor"],
+            }),
+            schneiderElectricExtend.temperatureSensorType({
+                endpointName: "floor",
+            }),
+            m.enumLookup({
+                name: "temperature_display_mode",
+                lookup: { celsius: 0 },
+                cluster: "hvacUserInterfaceCfg",
+                attribute: "tempDisplayMode",
+                description: "The unit of the temperature displayed on the device screen. Celsius is the only supported unit.",
+                entityCategory: "config",
+            }),
+            m.binary({
+                name: "child_lock",
+                valueOn: ["LOCK", 1],
+                valueOff: ["UNLOCK", 0],
+                cluster: "hvacUserInterfaceCfg",
+                attribute: "keypadLockout",
+                description: "Enables/disables physical input on the device",
+                access: "ALL",
+                reporting: { min: 0, max: 3600, change: 0 },
+            }),
+            schneiderElectricExtend.addWiserDeviceInfoCluster(),
         ],
-        configure: async (device, coordinatorEndpoint) => {
-            const endpoint1 = device.getEndpoint(1);
-            const endpoint2 = device.getEndpoint(2);
-            await reporting.bind(endpoint1, coordinatorEndpoint, ["hvacThermostat"]);
-            await reporting.thermostatPIHeatingDemand(endpoint1);
-            await reporting.thermostatOccupiedHeatingSetpoint(endpoint1);
-            await reporting.bind(endpoint2, coordinatorEndpoint, ["msTemperatureMeasurement"]);
-            await reporting.temperature(endpoint2);
-            await endpoint1.read("hvacUserInterfaceCfg", ["keypadLockout", "tempDisplayMode"]);
-        },
     },
     {
         zigbeeModel: ["WDE011680"],
         model: "WDE011680",
         vendor: "Schneider Electric",
         description: "Smart thermostat",
-        fromZigbee: [fz.stelpro_thermostat, fz.metering, fzLocal.wiser_device_info, fz.hvac_user_interface, fz.temperature],
+        fromZigbee: [fzLocal.thermostat_running_state_from_piheat, fz.metering, fzLocal.wiser_device_info, fz.hvac_user_interface, fz.temperature],
         toZigbee: [
             tz.thermostat_occupied_heating_setpoint,
             tz.thermostat_system_mode,
             tz.thermostat_running_state,
             tz.thermostat_local_temperature,
             tz.thermostat_control_sequence_of_operation,
-            tz.schneider_thermostat_keypad_lockout,
+            tzLocal.schneider_thermostat_keypad_lockout,
             tz.thermostat_temperature_display_mode,
         ],
         extend: [
@@ -2688,14 +3227,21 @@ exports.definitions = [
         model: "S520619",
         vendor: "Schneider Electric",
         description: "Wiser Odace Smart thermostat",
-        fromZigbee: [fz.stelpro_thermostat, fz.metering, fzLocal.wiser_device_info, fz.hvac_user_interface, fz.temperature, fz.occupancy],
+        fromZigbee: [
+            fzLocal.thermostat_running_state_from_piheat,
+            fz.metering,
+            fzLocal.wiser_device_info,
+            fz.hvac_user_interface,
+            fz.temperature,
+            fz.occupancy,
+        ],
         toZigbee: [
             tz.thermostat_occupied_heating_setpoint,
             tz.thermostat_occupied_cooling_setpoint,
             tz.thermostat_system_mode,
             tz.thermostat_local_temperature,
             tz.thermostat_control_sequence_of_operation,
-            tz.schneider_thermostat_keypad_lockout,
+            tzLocal.schneider_thermostat_keypad_lockout,
             tz.thermostat_temperature_display_mode,
             tz.thermostat_running_state,
         ],
@@ -2789,12 +3335,22 @@ exports.definitions = [
             e.power_factor(),
             e.energy(),
             e.ac_frequency(),
-            e.numeric("voltage_phase_l1_l2", ea.STATE).withUnit("V").withDescription("Measured electrical potential value between phase L1 and L2"),
-            e.numeric("voltage_phase_l2_l3", ea.STATE).withUnit("V").withDescription("Measured electrical potential value between phase L2 and L3"),
-            e.numeric("voltage_phase_l1_l3", ea.STATE).withUnit("V").withDescription("Measured electrical potential value between phase L1 and L3"),
-            e.numeric("current_phase_l1", ea.STATE).withUnit("A").withDescription("Instantaneous measured electrical current on phase L1"),
-            e.numeric("current_phase_l2", ea.STATE).withUnit("A").withDescription("Instantaneous measured electrical current on phase L2"),
-            e.numeric("current_phase_l3", ea.STATE).withUnit("A").withDescription("Instantaneous measured electrical current on phase L3"),
+            e.numeric("voltage_phase_ab", ea.STATE).withUnit("V").withDescription("Measured electrical potential value between phase L1 and L2"),
+            e.numeric("voltage_phase_bc", ea.STATE).withUnit("V").withDescription("Measured electrical potential value between phase L2 and L3"),
+            e.numeric("voltage_phase_ca", ea.STATE).withUnit("V").withDescription("Measured electrical potential value between phase L1 and L3"),
+            e.numeric("current_phase_a", ea.STATE).withUnit("A").withDescription("Instantaneous measured electrical current on phase L1"),
+            e.numeric("current_phase_b", ea.STATE).withUnit("A").withDescription("Instantaneous measured electrical current on phase L2"),
+            e.numeric("current_phase_c", ea.STATE).withUnit("A").withDescription("Instantaneous measured electrical current on phase L3"),
+        ],
+    },
+    {
+        zigbeeModel: ["UFH"],
+        model: "CCTFR6000",
+        vendor: "Schneider Electric",
+        description: "6 Channel Boiler Actuator",
+        extend: [
+            m.deviceEndpoints({ endpoints: { "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8 } }),
+            m.onOff({ powerOnBehavior: false, endpointNames: ["1", "2", "3", "4", "5", "6", "7", "8"] }),
         ],
     },
 ];