@willieee802/zigbee-herdsman-converters 19.44.3 → 19.45.0

package/dist/devices/ctm.js

@@ -44,6 +44,710 @@ const reporting = __importStar(require("../lib/reporting"));
 const utils = __importStar(require("../lib/utils"));
 const e = exposes.presets;
 const ea = exposes.access;
+const cluster = {
+    addCtmGroupConfigCluster: () => m.deviceAddCustomCluster("ctmGroupConfig", {
+        name: "ctmGroupConfig",
+        ID: 0xfea7,
+        manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+        attributes: {
+            groupId: { name: "groupId", ID: 0x0000, type: zigbee_herdsman_1.Zcl.DataType.UINT16, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    addCtmStoveGuardCluster: () => m.deviceAddCustomCluster("ctmStoveGuard", {
+        name: "ctmStoveGuard",
+        ID: 0xffc9, // 65481
+        manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+        attributes: {
+            alarmStatus: { name: "alarmStatus", ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS }, // .UINT8
+            batteryLow: { name: "batteryLow", ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            stoveTemperature: {
+                name: "stoveTemperature",
+                ID: 0x0003,
+                type: zigbee_herdsman_1.Zcl.DataType.UINT16,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            },
+            ambientTemperature: {
+                name: "ambientTemperature",
+                ID: 0x0004,
+                type: zigbee_herdsman_1.Zcl.DataType.UINT16,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            },
+            active: { name: "active", ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            runtime: { name: "runtime", ID: 0x0006, type: zigbee_herdsman_1.Zcl.DataType.UINT16, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            runtimeTimeout: {
+                name: "runtimeTimeout",
+                ID: 0x0007,
+                type: zigbee_herdsman_1.Zcl.DataType.UINT16,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            },
+            resetReason: { name: "resetReason", ID: 0x0008, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            dipSwitch: { name: "dipSwitch", ID: 0x0009, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            swVersion: { name: "swVersion", ID: 0x000a, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            hwVersion: { name: "hwVersion", ID: 0x000b, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            bootloaderVersion: {
+                name: "bootloaderVersion",
+                ID: 0x000c,
+                type: zigbee_herdsman_1.Zcl.DataType.UINT8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            },
+            model: { name: "model", ID: 0x000d, type: zigbee_herdsman_1.Zcl.DataType.UINT16, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            //  Use type IEEE_ADDR for EmberEUI64
+            relayAddress: {
+                name: "relayAddress",
+                ID: 0x0010,
+                type: zigbee_herdsman_1.Zcl.DataType.IEEE_ADDR,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            },
+            currentFlag: { name: "currentFlag", ID: 0x0100, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            relayCurrent: { name: "relayCurrent", ID: 0x0101, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            relayStatus: { name: "relayStatus", ID: 0x0102, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            externalButton: {
+                name: "externalButton",
+                ID: 0x0103,
+                type: zigbee_herdsman_1.Zcl.DataType.UINT8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            },
+            relayAlarm: { name: "relayAlarm", ID: 0x0104, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            relayAlarmStatus: {
+                name: "relayAlarmStatus",
+                ID: 0x0105,
+                type: zigbee_herdsman_1.Zcl.DataType.UINT8,
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    addCtmGenOnOffCluster: () => m.deviceAddCustomCluster("genOnOff", {
+        name: "genOnOff",
+        ID: zigbee_herdsman_1.Zcl.Clusters.genOnOff.ID,
+        attributes: {
+            deviceMode: { name: "deviceMode", ID: 0x2200, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+            deviceEnabled: { name: "deviceEnabled", ID: 0x2201, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+            childLock: { name: "childLock", ID: 0x2202, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+            currentFlag: { name: "currentFlag", ID: 0x5000, type: zigbee_herdsman_1.Zcl.DataType.UINT8, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+            relayState: { name: "relayState", ID: 0x5001, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    addCtmToHvacThermostatCluster: () => m.deviceAddCustomCluster("hvacThermostat", {
+        name: "hvacThermostat",
+        ID: zigbee_herdsman_1.Zcl.Clusters.hvacThermostat.ID,
+        attributes: {
+            ctmLoad: { name: "ctmLoad", ID: 0x0401, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
+            ctmDisplayText: { name: "ctmDisplayText", ID: 0x0402, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+            ctmSensor: { name: "ctmSensor", ID: 0x0403, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            ctmRegulatorMode: { name: "ctmRegulatorMode", ID: 0x0405, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+            ctmPowerStatus: { name: "ctmPowerStatus", ID: 0x0406, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+            ctmMeanPower: { name: "ctmMeanPower", ID: 0x0408, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+            ctmFloorTemp: { name: "ctmFloorTemp", ID: 0x0409, type: zigbee_herdsman_1.Zcl.DataType.INT16 },
+            ctmNightSwitching: { name: "ctmNightSwitching", ID: 0x0411, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+            ctmFrostGuard: { name: "ctmFrostGuard", ID: 0x0412, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+            ctmChildLock: { name: "ctmChildLock", ID: 0x0413, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+            ctmMaxFloorTemp: { name: "ctmMaxFloorTemp", ID: 0x0414, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            ctmRelayState: { name: "ctmRelayState", ID: 0x0415, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+            ctmRegulatorSetpoint: { name: "ctmRegulatorSetpoint", ID: 0x0420, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true },
+            ctmRegulationMode: { name: "ctmRegulationMode", ID: 0x0421, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true },
+            ctmOperationMode: { name: "ctmOperationMode", ID: 0x0422, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true },
+            ctmMaxFloorGuard: { name: "ctmMaxFloorGuard", ID: 0x0423, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+            ctmWeeklyTimer: { name: "ctmWeeklyTimer", ID: 0x0424, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
+            ctmFrostGuardSetpoint: { name: "ctmFrostGuardSetpoint", ID: 0x0425, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true },
+            ctmExternalTemp: { name: "ctmExternalTemp", ID: 0x0426, type: zigbee_herdsman_1.Zcl.DataType.INT16 },
+            ctmExternalSensorSource: { name: "ctmExternalSensorSource", ID: 0x0428, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true },
+            ctmAirTemp: { name: "ctmAirTemp", ID: 0x0429, type: zigbee_herdsman_1.Zcl.DataType.INT16 },
+            ctmFloorSensorError: { name: "ctmFloorSensorError", ID: 0x042b, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+            ctmAirSensorError: { name: "ctmAirSensorError", ID: 0x042c, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+};
+const _ctmExtend = {
+    groupId: (args) => m.numeric({
+        name: "group_id",
+        cluster: "ctmGroupConfig",
+        attribute: "groupId",
+        description: "The device sends commands with this group ID. Put devices in this group to control them.",
+        access: "STATE",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+    }),
+    alarmStatus: (args) => m.enumLookup({
+        name: "alarm_status",
+        cluster: "ctmStoveGuard",
+        attribute: "alarmStatus",
+        description: "Alarm status.",
+        access: "STATE",
+        lookup: {
+            OK: 0x00,
+            Tamper: 0x01,
+            "High Temperature": 0x02,
+            Timer: 0x03,
+            "Battery alarm": 0x07,
+            Error: 0x08,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    batteryLow: (args) => m.enumLookup({
+        name: "battery_low",
+        cluster: "ctmStoveGuard",
+        attribute: "batteryLow",
+        description: "Indicates the status of the battery ('OK' or 'Change')",
+        access: "STATE",
+        lookup: {
+            "Battery OK": 0x00,
+            "Change battery": 0x01,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    stoveTemperature: (args) => m.numeric({
+        name: "stove_temperature",
+        cluster: "ctmStoveGuard",
+        attribute: "stoveTemperature",
+        description: "Stove temperature",
+        access: "STATE",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ambientTemperature: (args) => m.numeric({
+        name: "ambient_temperature",
+        cluster: "ctmStoveGuard",
+        attribute: "ambientTemperature",
+        description: "X",
+        access: "STATE",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    active: (args) => m.enumLookup({
+        name: "active",
+        cluster: "ctmStoveGuard",
+        attribute: "active",
+        description: "Stove guard active/inactive (Stove in use)",
+        access: "STATE",
+        lookup: {
+            Inactive: 0x00,
+            Active: 0x01,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    runtime: (args) => m.numeric({
+        name: "runtime",
+        cluster: "ctmStoveGuard",
+        attribute: "runtime",
+        description: "",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    runtimeTimeout: (args) => m.numeric({
+        name: "runtime_timeout",
+        cluster: "ctmStoveGuard",
+        attribute: "runtimeTimeout",
+        description: "",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    resetReason: (args) => m.enumLookup({
+        name: "reset_reason",
+        cluster: "ctmStoveGuard",
+        attribute: "resetReason",
+        description: "Reset reason.",
+        access: "STATE",
+        lookup: {
+            Unknown: 0x00,
+            "Power-on Reset": 0x01,
+            "External Reset": 0x02,
+            "Brown-Out Reset": 0x03,
+            "Watchdog Reset": 0x04,
+            "Program and debug interface reset": 0x05,
+            "Software reset": 0x06,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    dipSwitch: (args) => m.numeric({
+        name: "dip_switch",
+        cluster: "ctmStoveGuard",
+        attribute: "dipSwitch",
+        description: "Dip switch",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    swVersion: (args) => m.numeric({
+        name: "sw_version",
+        cluster: "ctmStoveGuard",
+        attribute: "swVersion",
+        description: "Software version",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    hwVersion: (args) => m.numeric({
+        name: "hw_version",
+        cluster: "ctmStoveGuard",
+        attribute: "hwVersion",
+        description: "Hardware version",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    bootloaderVersion: (args) => m.numeric({
+        name: "bootloader_version",
+        cluster: "ctmStoveGuard",
+        attribute: "bootloaderVersion",
+        description: "Bootloader version",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    model: (args) => m.enumLookup({
+        name: "model",
+        cluster: "ctmStoveGuard",
+        attribute: "model",
+        description: "Stove guard model.",
+        access: "STATE",
+        lookup: {
+            "mKomfy 1.8": 0x0001,
+            "mKomfy Infinity": 0x0002,
+            "mKomfy Hybrid": 0x0003,
+            "mKomfy Tak": 0x0004,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    relayAddress: (args) => m.numeric({
+        name: "relay_address",
+        cluster: "ctmStoveGuard",
+        attribute: "relayAddress",
+        description: "",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    currentFlagStove: (args) => m.enumLookup({
+        name: "current_flag",
+        cluster: "ctmStoveGuard",
+        attribute: "currentFlag",
+        description: ")",
+        access: "STATE",
+        lookup: {
+            False: 0x00,
+            True: 0x01,
+            Unknown: 0xff,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    relayCurrent: (args) => m.numeric({
+        name: "relay_current",
+        cluster: "ctmStoveGuard",
+        attribute: "relayCurrent",
+        description: "Relay current.",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    relayStatus: (args) => m.enumLookup({
+        name: "relay_status",
+        cluster: "ctmStoveGuard",
+        attribute: "relayStatus",
+        description: "Relay status.",
+        access: "STATE",
+        lookup: {
+            OFF: 0x00,
+            ON: 0x01,
+            "Not present": 0x02,
+            Unknown: 0xff,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    externalButton: (args) => m.enumLookup({
+        name: "external_button",
+        cluster: "ctmStoveGuard",
+        attribute: "externalButton",
+        description: "External button.",
+        access: "STATE",
+        lookup: {
+            "Not clicked": 0x00,
+            "Button clicked": 0x01,
+            Unknown: 0xff,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    relayAlarm: (args) => m.enumLookup({
+        name: "relay_alarm",
+        cluster: "ctmStoveGuard",
+        attribute: "relayAlarm",
+        description: "Relay alarm.",
+        access: "STATE",
+        lookup: {
+            OK: 0x00,
+            "No communication": 0x01,
+            "Over Current": 0x02,
+            "Over Temperature": 0x03,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    relayAlarmStatus: (args) => m.enumLookup({
+        name: "relay_alarm_status",
+        cluster: "ctmStoveGuard",
+        attribute: "relayAlarmStatus",
+        description: "Relay alarm status.",
+        access: "STATE",
+        lookup: {
+            OK: 0x00,
+            Tamper: 0x01,
+            "High Temperature": 0x02,
+            Timer: 0x03,
+            "Battery alarm": 0x07,
+            Error: 0x08,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    deviceMode: (args) => m.enumLookup({
+        name: "device_mode",
+        cluster: "genOnOff",
+        attribute: "deviceMode",
+        description: "ZZZ",
+        access: "STATE",
+        lookup: {
+            "AU: Astro clock": 0x00,
+            "TM: Timer": 0x01,
+            "DU: Daily timer": 0x02,
+            "UU: Weekly Timer": 0x03,
+        },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    deviceEnabled: (args) => m.binary({
+        name: "device_enabled",
+        cluster: "genOnOff",
+        attribute: "deviceEnabled",
+        description: "Turn the device on or off",
+        access: "ALL",
+        valueOn: ["On", 0],
+        valueOff: ["Off", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    childLock: (args) => m.binary({
+        name: "child_lock",
+        cluster: "genOnOff",
+        attribute: "childLock",
+        description: "Enables/disables physical input on the device.",
+        access: "STATE_SET",
+        valueOn: ["LOCK", 1],
+        valueOff: ["UNLOCK", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    currentFlag: (args) => m.numeric({
+        name: "current_flag",
+        cluster: "genOnOff",
+        attribute: "currentFlag",
+        description: "Current flag.",
+        access: "STATE_SET",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    relayState: (args) => m.binary({
+        name: "state",
+        cluster: "genOnOff",
+        attribute: "relayState",
+        description: "Relay state.",
+        access: "STATE_SET",
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmLoad: (args) => m.numeric({
+        name: "load",
+        cluster: "hvacThermostat",
+        attribute: "ctmLoad",
+        description: "Load in W when heating is on (between 0-3600 W). The thermostat uses the value as input to the mean_power calculation.",
+        unit: "W",
+        valueMin: 0,
+        valueMax: 3600,
+        access: "ALL",
+        entityCategory: "config",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmDisplayText: (args) => m.text({
+        name: "display_text",
+        cluster: "hvacThermostat",
+        attribute: "ctmDisplayText",
+        description: "Displayed text on thermostat display (zone). Max 19 characters",
+        access: "ALL",
+        entityCategory: "config",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmSensor: (args) => m.enumLookup({
+        name: "sensor",
+        cluster: "hvacThermostat",
+        attribute: "ctmSensor",
+        description: "Select temperature sensor to use",
+        lookup: {
+            "Air sensor": 0x00,
+            "Floor sensor": 0x01,
+            "External sensor": 0x02,
+            Regulator: 0x03,
+            "MV Air": 0x04,
+            "MV External Air": 0x05,
+            "MV Regulator": 0x06,
+        },
+        access: "ALL",
+        entityCategory: "config",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmRegulatorMode: (args) => m.binary({
+        name: "regulator_mode",
+        cluster: "hvacThermostat",
+        attribute: "ctmRegulatorMode",
+        description: "Device in regulator or thermostat mode.",
+        access: "ALL",
+        reporting: { min: "1_SECOND", max: "MAX", change: null },
+        valueOn: ["regulator", 1],
+        valueOff: ["thermostat", 0],
+        entityCategory: "config",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmPowerStatus: (args) => m.binary({
+        name: "power_status",
+        cluster: "hvacThermostat",
+        attribute: "ctmPowerStatus",
+        description: "Relay state.",
+        access: "STATE_GET",
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmMeanPower: (args) => m.numeric({
+        name: "mean_power",
+        cluster: "hvacThermostat",
+        attribute: "ctmMeanPower",
+        description: "Reports average power usage last 10 minutes.",
+        unit: "W",
+        access: "STATE_GET",
+        entityCategory: "diagnostic",
+        reporting: { min: "MIN", max: "1_HOUR", change: 5 },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmFloorTemp: (args) => m.numeric({
+        name: "floor_temp",
+        cluster: "hvacThermostat",
+        attribute: "ctmFloorTemp",
+        scale: 100,
+        description: "Current temperature measured from the floor sensor",
+        unit: "°C",
+        access: "STATE_GET",
+        reporting: { min: "MIN", max: "1_HOUR", change: 10 },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmNightSwitching: (args) => m.binary({
+        name: "night_switching",
+        cluster: "hvacThermostat",
+        attribute: "ctmNightSwitching",
+        description: "Relay state.",
+        access: "STATE_SET",
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmFrostGuard: (args) => m.binary({
+        name: "frost_guard",
+        cluster: "hvacThermostat",
+        attribute: "ctmFrostGuard",
+        description: "When frost guard is ON, it is activated when the thermostat is switched OFF with the ON/OFF button." +
+            'At the same time, the display will fade and the text "Frostsikring x °C" appears in the display and remains until the ' +
+            "thermostat is switched on again. ",
+        access: "ALL",
+        entityCategory: "config",
+        reporting: { min: "MIN", max: "MAX", change: null },
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmChildLockThermostat: (args) => m.binary({
+        name: "child_lock",
+        cluster: "hvacThermostat",
+        attribute: "ctmChildLock",
+        description: "Enables/disables physical input on the device.",
+        access: "ALL",
+        reporting: { min: "MIN", max: "MAX", change: null },
+        valueOn: ["LOCK", 1],
+        valueOff: ["UNLOCK", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmMaxFloorTemp: (args) => m.numeric({
+        name: "max_floor_temp",
+        cluster: "hvacThermostat",
+        attribute: "ctmMaxFloorTemp",
+        description: "Maximum allowed floor temperature.",
+        valueMin: 15,
+        valueMax: 40,
+        unit: "°C",
+        access: "ALL",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmRelayState: (args) => m.binary({
+        name: "relay_state",
+        cluster: "hvacThermostat",
+        attribute: "ctmRelayState",
+        description: "Is heating ON or OFF.",
+        access: "STATE",
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmRegulatorSetpoint: (args) => m.numeric({
+        name: "regulator_setpoint",
+        cluster: "hvacThermostat",
+        attribute: "ctmRegulatorSetpoint",
+        description: "Setpoint in %, use only when the thermostat is in regulator mode.",
+        valueMin: 1,
+        valueMax: 99,
+        unit: "%",
+        access: "ALL",
+        reporting: { min: "MIN", max: "1_HOUR", change: 1 },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmRegulationMode: (args) => m.enumLookup({
+        name: "ctm_regulaton_mode",
+        cluster: "hvacThermostat",
+        attribute: "ctmRegulationMode",
+        description: "Regulation mode",
+        lookup: {
+            Thermostat: 0x00,
+            Regulator: 0x01,
+            Zzilent: 0x02,
+        },
+        access: "ALL",
+        entityCategory: "config",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmOperationMode: (args) => 
+    // const presetLookup = {0: "off", 1: "away", 2: "sleep", 3: "home"};
+    m.enumLookup({
+        name: "ctm_operation_mode",
+        cluster: "hvacThermostat",
+        attribute: "ctmOperationMode",
+        description: "Regulation mode",
+        lookup: {
+            OFF: 0x00,
+            "Anti-Freeze": "0x01",
+            "Night Saving": 0x02,
+            "Comfort/ON": 0x03,
+        },
+        access: "ALL",
+        reporting: { min: "MIN", max: "1_HOUR", change: 1 },
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmMaxFloorGuard: (args) => m.binary({
+        name: "max_floor_guard",
+        cluster: "hvacThermostat",
+        attribute: "ctmMaxFloorGuard",
+        description: "If 'Max floor guard' is ON the thermostat will stop heating if the floor temperature becomes higher than 'Max floor temp'.",
+        access: "ALL",
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmWeeklyTimer: (args) => m.binary({
+        name: "weekly_timer",
+        cluster: "hvacThermostat",
+        attribute: "ctmWeeklyTimer",
+        description: "Weekly timer enabled/disabled.",
+        access: "ALL",
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmFrostGuardSetpoint: (args) => m.numeric({
+        name: "frost_guard_setpoint",
+        cluster: "hvacThermostat",
+        attribute: "ctmFrostGuardSetpoint",
+        description: "Temperature setpoint used when frost guard is active.",
+        access: "ALL",
+        unit: "°C",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmExternalTemp: (args) => m.numeric({
+        name: "external_temp",
+        cluster: "hvacThermostat",
+        attribute: "ctmExternalTemp",
+        scale: 100,
+        description: "Current temperature measured from the external sensor.",
+        access: "STATE_GET",
+        unit: "°C",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmExternalSensorSource: (args) => m.numeric({
+        name: "external_sensor_source",
+        cluster: "hvacThermostat",
+        attribute: "ctmExternalSensorSource",
+        description: "External sensor source.",
+        access: "ALL",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmAirTemp: (args) => m.numeric({
+        name: "air_temp",
+        cluster: "hvacThermostat",
+        attribute: "ctmAirTemp",
+        scale: 100,
+        description: "Current temperature measured from the air sensor.",
+        access: "STATE_GET",
+        reporting: { min: "MIN", max: "1_HOUR", change: 0.1 },
+        unit: "°C",
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmFloorSensorError: (args) => m.binary({
+        name: "floor_sensor_error",
+        cluster: "hvacThermostat",
+        attribute: "ctmFloorSensorError",
+        description: "Indicates a floor sensor error.",
+        access: "STATE_GET",
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+    ctmAirSensorError: (args) => m.binary({
+        name: "air_sensor_error",
+        cluster: "hvacThermostat",
+        attribute: "ctmAirSensorError",
+        description: "Indicates an air temperature sensor error.",
+        access: "STATE_GET",
+        valueOn: ["ON", 1],
+        valueOff: ["OFF", 0],
+        zigbeeCommandOptions: { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS },
+        ...args,
+    }),
+};
 const fzLocal = {
     ctm_mbd_device_enabled: {
         cluster: "genOnOff",
@@ -63,9 +767,9 @@ const fzLocal = {
         convert: (model, msg, publish, options, meta) => {
             const result = {};
             const data = msg.data;
-            if (data[0x2200] !== undefined) {
+            if (data.deviceMode !== undefined) {
                 const deviceModeLookup = { 0: "astro_clock", 1: "timer", 2: "daily_timer", 3: "weekly_timer" };
-                result.device_mode = utils.getFromLookup(data[0x2200], deviceModeLookup);
+                result.device_mode = utils.getFromLookup(data.deviceMode, deviceModeLookup);
             }
             return result;
         },
@@ -76,8 +780,8 @@ const fzLocal = {
         convert: (model, msg, publish, options, meta) => {
             const result = {};
             const data = msg.data;
-            if (data[0x2201] !== undefined) {
-                result.device_enabled = data[0x2201] ? "ON" : "OFF";
+            if (data.deviceEnabled !== undefined) {
+                result.device_enabled = data.deviceEnabled ? "ON" : "OFF";
             }
             return result;
         },
@@ -88,20 +792,8 @@ const fzLocal = {
         convert: (model, msg, publish, options, meta) => {
             const result = {};
             const data = msg.data;
-            if (data[0x2202] !== undefined) {
-                result.child_lock = data[0x2202] ? "locked" : "unlocked";
-            }
-            return result;
-        },
-    },
-    ctm_current_flag: {
-        cluster: "genOnOff",
-        type: ["attributeReport", "readResponse"],
-        convert: (model, msg, publish, options, meta) => {
-            const result = {};
-            const data = msg.data;
-            if (data[0x5000] !== undefined) {
-                result.current_flag = data[0x5000];
+            if (data.childLock !== undefined) {
+                result.child_lock = data.childLock ? "locked" : "unlocked";
             }
             return result;
         },
@@ -112,8 +804,8 @@ const fzLocal = {
         convert: (model, msg, publish, options, meta) => {
             const result = {};
             const data = msg.data;
-            if (data[0x5001] !== undefined) {
-                result.state = data[0x5001] ? "ON" : "OFF";
+            if (data.relayState !== undefined) {
+                result.state = data.relayState ? "ON" : "OFF";
             }
             return result;
         },
@@ -124,190 +816,74 @@ const fzLocal = {
         convert: (model, msg, publish, options, meta) => {
             const result = {};
             const data = msg.data;
-            if (data[0x0401] !== undefined) {
-                // Load
-                result.load = data[0x0401];
+            if (data.ctmLoad !== undefined) {
+                result.load = data.ctmLoad;
             }
-            if (data.elkoLoad !== undefined) {
-                // Load
-                result.load = data.elkoLoad;
+            if (data.ctmDisplayText !== undefined) {
+                result.display_text = data.ctmDisplayText;
             }
-            if (data[0x0402] !== undefined) {
-                // Display text
-                result.display_text = data[0x0402];
+            if (data.ctmRegulatorMode !== undefined) {
+                result.regulator_mode = data.ctmRegulatorMode ? "regulator" : "thermostat";
             }
-            if (data.elkoDisplayText !== undefined) {
-                // Display text
-                result.display_text = data.elkoDisplayText;
+            if (data.ctmPowerStatus !== undefined) {
+                result.power_status = data.ctmPowerStatus ? "ON" : "OFF";
             }
-            if (data[0x0403] !== undefined) {
-                // Sensor
-                const sensorModeLookup = {
-                    0: "air",
-                    1: "floor",
-                    2: "external",
-                    3: "regulator",
-                    4: "mv_air",
-                    5: "mv_external",
-                    6: "mv_regulator",
-                };
-                result.sensor = utils.getFromLookup(data[0x0403], sensorModeLookup);
+            if (data.ctmMeanPower !== undefined) {
+                result.mean_power = data.ctmMeanPower;
             }
-            if (data.elkoSensor !== undefined) {
-                // Sensor
-                const sensorModeLookup = {
-                    0: "air",
-                    1: "floor",
-                    2: "external",
-                    3: "regulator",
-                    4: "mv_air",
-                    5: "mv_external",
-                    6: "mv_regulator",
-                };
-                result.sensor = utils.getFromLookup(data.elkoSensor, sensorModeLookup);
+            if (data.ctmFloorTemp !== undefined) {
+                result.floor_temp = utils.precisionRound(data.ctmFloorTemp, 2) / 100;
             }
-            if (data[0x0405] !== undefined) {
-                // Regulator mode
-                result.regulator_mode = data[0x0405] ? "regulator" : "thermostat";
+            if (data.ctmFrostGuard !== undefined) {
+                result.frost_guard = data.ctmFrostGuard ? "ON" : "OFF";
             }
-            if (data.elkoRegulatorMode !== undefined) {
-                // Regulator mode
-                result.regulator_mode = data.elkoRegulatorMode ? "regulator" : "thermostat";
+            if (data.ctmChildLock !== undefined) {
+                result.child_lock = data.ctmChildLock ? "LOCK" : "UNLOCK";
             }
-            if (data[0x0406] !== undefined) {
-                // Power status
-                result.power_status = data[0x0406] ? "ON" : "OFF";
+            if (data.ctmRelayState !== undefined) {
+                result.running_state = data.ctmRelayState ? "heat" : "idle";
             }
-            if (data.elkoPowerStatus !== undefined) {
-                // Power status
-                result.power_status = data.elkoPowerStatus ? "ON" : "OFF";
+            if (data.ctmRegulatorSetpoint !== undefined) {
+                result.regulator_setpoint = data.ctmRegulatorSetpoint;
             }
-            if (data[0x0408] !== undefined) {
-                // Mean power
-                result.mean_power = data[0x0408];
-            }
-            if (data.elkoMeanPower !== undefined) {
-                // Mean power
-                result.mean_power = data.elkoMeanPower;
-            }
-            if (data[0x0409] !== undefined) {
-                // Floor temp
-                result.floor_temp = utils.precisionRound(data[0x0409], 2) / 100;
-            }
-            if (data.elkoExternalTemp !== undefined) {
-                // External temp (floor)
-                result.floor_temp = utils.precisionRound(data.elkoExternalTemp, 2) / 100;
-            }
-            if (data[0x0411] !== undefined) {
-                // Night switching
-                result.night_switching = data[0x0411] ? "ON" : "OFF";
-            }
-            if (data.elkoNightSwitching !== undefined) {
-                // Night switching
-                result.night_switching = data.elkoNightSwitching ? "ON" : "OFF";
-            }
-            if (data[0x0412] !== undefined) {
-                // Frost guard
-                result.frost_guard = data[0x0412] ? "ON" : "OFF";
-            }
-            if (data.elkoFrostGuard !== undefined) {
-                // Frost guard
-                result.frost_guard = data.elkoFrostGuard ? "ON" : "OFF";
-            }
-            if (data[0x0413] !== undefined) {
-                // Child lock
-                result.child_lock = data[0x0413] ? "LOCK" : "UNLOCK";
-            }
-            if (data.elkoChildLock !== undefined) {
-                // Child lock
-                result.child_lock = data.elkoChildLock ? "LOCK" : "UNLOCK";
-            }
-            if (data[0x0414] !== undefined) {
-                // Max floor temp
-                result.max_floor_temp = data[0x0414];
-            }
-            if (data.elkoMaxFloorTemp !== undefined) {
-                // Max floor temp
-                result.max_floor_temp = data.elkoMaxFloorTemp;
-            }
-            if (data[0x0415] !== undefined) {
-                // Running_state
-                result.running_state = data[0x0415] ? "heat" : "idle";
-            }
-            if (data.elkoRelayState !== undefined) {
-                // Running_state
-                result.running_state = data.elkoRelayState ? "heat" : "idle";
-            }
-            if (data[0x0420] !== undefined) {
-                // Regulator setpoint
-                result.regulator_setpoint = data[0x0420];
-            }
-            if (data[0x0421] !== undefined) {
-                // Regulation mode
+            if (data.ctmRegulationMode !== undefined) {
                 const regulationModeLookup = { 0: "thermostat", 1: "regulator", 2: "zzilent" };
-                result.regulation_mode = utils.getFromLookup(data[0x0421], regulationModeLookup);
+                result.regulation_mode = utils.getFromLookup(data.ctmRegulationMode, regulationModeLookup);
             }
-            if (data[0x0422] !== undefined) {
-                // Operation mode
+            if (data.ctmOperationMode !== undefined) {
                 const presetLookup = { 0: "off", 1: "away", 2: "sleep", 3: "home" };
                 const systemModeLookup = { 0: "off", 1: "off", 2: "off", 3: "heat" };
-                result.preset = utils.getFromLookup(data[0x0422], presetLookup);
-                result.system_mode = utils.getFromLookup(data[0x0422], systemModeLookup);
-            }
-            if (data[0x0423] !== undefined) {
-                // Maximum floor temp guard
-                result.max_floor_guard = data[0x0423] ? "ON" : "OFF";
-            }
-            if (data[0x0424] !== undefined) {
-                // Weekly timer enabled
-                result.weekly_timer = data[0x0424] ? "ON" : "OFF";
-            }
-            if (data[0x0425] !== undefined) {
-                // Frost guard setpoint
-                result.frost_guard_setpoint = data[0x0425];
-            }
-            if (data[0x0426] !== undefined) {
-                // External temperature
-                result.external_temp = utils.precisionRound(data[0x0426], 2) / 100;
+                result.preset = utils.getFromLookup(data.ctmOperationMode, presetLookup);
+                result.system_mode = utils.getFromLookup(data.ctmOperationMode, systemModeLookup);
             }
-            if (data[0x0428] !== undefined) {
-                // External sensor source
-                result.exteral_sensor_source = data[0x0428];
+            if (data.ctmExternalTemp !== undefined) {
+                result.external_temp = utils.precisionRound(data.ctmExternalTemp, 2) / 100;
             }
-            if (data[0x0429] !== undefined) {
-                // Current air temperature
-                result.air_temp = utils.precisionRound(data[0x0429], 2) / 100;
-            }
-            if (data[0x0424] !== undefined) {
-                // Floor Sensor Error
-                result.floor_sensor_error = data[0x042b] ? "error" : "ok";
-            }
-            if (data[0x0424] !== undefined) {
-                // External Air Sensor Error
-                result.exteral_sensor_error = data[0x042c] ? "error" : "ok";
+            if (data.ctmAirTemp !== undefined) {
+                result.air_temp = utils.precisionRound(data.ctmAirTemp, 2) / 100;
             }
             return result;
         },
     },
     ctm_group_config: {
-        cluster: "65191", // 0xFEA7 ctmGroupConfig
+        cluster: "ctmGroupConfig",
         type: ["attributeReport", "readResponse"],
         convert: (model, msg, publish, options, meta) => {
             const result = {};
             const data = msg.data;
-            if (data[0x0000] !== undefined) {
-                result.group_id = data[0x0000];
+            if (data.groupId !== undefined) {
+                result.group_id = data.groupId;
             }
             return result;
         },
     },
-    ctm_sove_guard: {
-        cluster: "65481", // 0xFFC9 ctmSoveGuard
+    ctm_stove_guard: {
+        cluster: "ctmStoveGuard",
         type: ["attributeReport", "readResponse"],
         convert: (model, msg, publish, options, meta) => {
             const result = {};
             const data = msg.data;
-            if (data[0x0001] !== undefined) {
+            if (data.alarmStatus !== undefined) {
                 // Alarm status
                 const alarmStatusLookup = {
                     0: "ok",
@@ -318,107 +894,14 @@ const fzLocal = {
                     5: "error",
                     255: "unknown",
                 };
-                result.alarm_status = utils.getFromLookup(data[0x0001], alarmStatusLookup);
+                result.alarm_status = utils.getFromLookup(data.alarmStatus, alarmStatusLookup);
             }
-            if (data[0x0002] !== undefined) {
+            if (data.batteryLow !== undefined) {
                 // Change battery
-                result.battery_low = !!data[0x0002];
-            }
-            if (data[0x0003] !== undefined) {
-                // Stove temperature
-                result.stove_temperature = data[0x0003];
-            }
-            if (data[0x0004] !== undefined) {
-                // Ambient temperature
-                result.ambient_temperature = data[0x0004];
-            }
-            if (data[0x0005] !== undefined) {
-                // Active
-                result.active = !!data[0x0005];
-            }
-            if (data[0x0006] !== undefined) {
-                // Runtime
-                result.runtime = data[0x0006];
-            }
-            if (data[0x0007] !== undefined) {
-                // Runtime timeout
-                result.runtime_timeout = data[0x0007];
-            }
-            if (data[0x0008] !== undefined) {
-                // Reset reason
-                const resetReasonLookup = {
-                    0: "unknown",
-                    1: "power_on",
-                    2: "external",
-                    3: "brown_out",
-                    4: "watchdog",
-                    5: "program_interface",
-                    6: "software",
-                    255: "unknown",
-                };
-                result.reset_reason = utils.getFromLookup(data[0x0008], resetReasonLookup);
-            }
-            if (data[0x0009] !== undefined) {
-                // Dip switch
-                result.dip_switch = data[0x0009];
-            }
-            if (data[0x000a] !== undefined) {
-                // Software version
-                result.sw_version = data[0x000a];
-            }
-            if (data[0x000b] !== undefined) {
-                // Hardware version
-                result.hw_version = data[0x000b];
-            }
-            if (data[0x000c] !== undefined) {
-                // Bootloader version
-                result.bootloader_version = data[0x000c];
-            }
-            if (data[0x000d] !== undefined) {
-                // Model
-                const modelLookup = { 0: "unknown", 1: "1_8", 2: "infinity", 3: "hybrid", 4: "tak", 255: "unknown" };
-                result.model = utils.getFromLookup(data[0x000d], modelLookup);
-            }
-            if (data[0x0010] !== undefined) {
-                // Relay address
-                result.relay_address = data[0x0010];
-            }
-            if (data[0x0100] !== undefined) {
-                // Relay current flag
-                const currentFlagLookup = { 0: "false", 1: "true", 255: "unknown" };
-                result.current_flag = utils.getFromLookup(data[0x0100], currentFlagLookup);
-            }
-            if (data[0x0101] !== undefined) {
-                // Relay current
-                result.relay_current = data[0x0101];
-            }
-            if (data[0x0102] !== undefined) {
-                // Relay status
-                const relayStatusLookup = { 0: "off", 1: "on", 2: "not_present", 255: "unknown" };
-                result.relay_status = utils.getFromLookup(data[0x0102], relayStatusLookup);
-            }
-            if (data[0x0103] !== undefined) {
-                // Relay external button
-                const relayStatusLookup = { 0: "not_clicked", 1: "clicked", 255: "unknown" };
-                result.external_button = utils.getFromLookup(data[0x0103], relayStatusLookup);
+                result.battery_low = !!data.batteryLow;
             }
-            if (data[0x0104] !== undefined) {
-                // Relay alarm
-                const relayAlarmLookup = { 0: "ok", 1: "no_communication", 2: "over_current", 3: "over_temperature", 255: "unknown" };
-                result.relay_alarm = utils.getFromLookup(data[0x0104], relayAlarmLookup);
-            }
-            if (data[0x0105] !== undefined) {
-                // Alarm status (from relay)
-                const relayAlarmStatusLookup = {
-                    0: "ok",
-                    1: "tamper",
-                    2: "high_temperatur",
-                    3: "timer",
-                    4: "battery_alarm",
-                    5: "error",
-                    255: "unknown",
-                };
-                result.relay_alarm_status = utils.getFromLookup(data[0x0105], relayAlarmStatusLookup);
+            if (data.active !== undefined) {
+                result.active = !!data.active;
             }
             return result;
         },
@@ -459,7 +942,7 @@ const tzLocal = {
     ctm_device_mode: {
         key: ["device_mode"],
         convertGet: async (entity, key, meta) => {
-            await entity.read("genOnOff", [0x2200]);
+            await entity.read("genOnOff", ["deviceMode"]);
         },
     },
     ctm_device_enabled: {
@@ -468,19 +951,13 @@ const tzLocal = {
             await entity.write("genOnOff", { 8705: { value: utils.getFromLookup(value, { OFF: 0, ON: 1 }), type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN } });
         },
         convertGet: async (entity, key, meta) => {
-            await entity.read("genOnOff", [0x2201]);
+            await entity.read("genOnOff", ["deviceEnabled"]);
         },
     },
     ctm_child_lock: {
         key: ["child_lock"],
         convertGet: async (entity, key, meta) => {
-            await entity.read("genOnOff", [0x2202]);
-        },
-    },
-    ctm_current_flag: {
-        key: ["current_flag"],
-        convertGet: async (entity, key, meta) => {
-            await entity.read("genOnOff", [0x5000], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+            await entity.read("genOnOff", ["childLock"]);
         },
     },
     ctm_relay_state: {
@@ -489,25 +966,20 @@ const tzLocal = {
             await entity.write("genOnOff", { 20481: { value: utils.getFromLookup(value, { OFF: 0, ON: 1 }), type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN } }, { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
         },
         convertGet: async (entity, key, meta) => {
-            await entity.read("genOnOff", [0x5001], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+            await entity.read("genOnOff", ["relayState"], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
         },
     },
     ctm_thermostat: {
         key: [
             "load",
             "display_text",
-            "sensor",
             "regulator_mode",
             "power_status",
             "system_mode",
-            "night_switching",
             "frost_guard",
-            "max_floor_temp",
             "regulator_setpoint",
             "regulation_mode",
-            "max_floor_guard",
             "weekly_timer",
-            "exteral_sensor_source",
         ],
         convertSet: async (entity, key, value, meta) => {
             switch (key) {
@@ -517,22 +989,6 @@ const tzLocal = {
                 case "display_text":
                     await entity.write("hvacThermostat", { 1026: { value: value, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR } });
                     break;
-                case "sensor":
-                    await entity.write("hvacThermostat", {
-                        1027: {
-                            value: utils.getFromLookup(value, {
-                                air: 0,
-                                floor: 1,
-                                external: 2,
-                                regulator: 3,
-                                mv_air: 4,
-                                mv_external: 5,
-                                mv_regulator: 6,
-                            }),
-                            type: zigbee_herdsman_1.Zcl.DataType.ENUM8,
-                        },
-                    });
-                    break;
                 case "regulator_mode":
                     await entity.write("hvacThermostat", {
                         1029: { value: utils.getFromLookup(value, { thermostat: 0, regulator: 1 }), type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
@@ -549,15 +1005,9 @@ const tzLocal = {
                         await entity.write("hvacThermostat", { 1058: { value: 3, type: zigbee_herdsman_1.Zcl.DataType.UINT8 } });
                     }
                     break;
-                case "night_switching":
-                    await entity.write("hvacThermostat", { 1041: { value: utils.getFromLookup(value, { OFF: 0, ON: 1 }), type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN } });
-                    break;
                 case "frost_guard":
                     await entity.write("hvacThermostat", { 1042: { value: utils.getFromLookup(value, { OFF: 0, ON: 1 }), type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN } });
                     break;
-                case "max_floor_temp":
-                    await entity.write("hvacThermostat", { 1044: { value: value, type: zigbee_herdsman_1.Zcl.DataType.UINT8 } });
-                    break;
                 case "regulator_setpoint":
                     await entity.write("hvacThermostat", { 1056: { value: value, type: zigbee_herdsman_1.Zcl.DataType.UINT8 } });
                     break;
@@ -569,15 +1019,9 @@ const tzLocal = {
                         },
                     });
                     break;
-                case "max_floor_guard":
-                    await entity.write("hvacThermostat", { 1059: { value: utils.getFromLookup(value, { OFF: 0, ON: 1 }), type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN } });
-                    break;
                 case "weekly_timer":
                     await entity.write("hvacThermostat", { 1060: { value: utils.getFromLookup(value, { OFF: 0, ON: 1 }), type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN } });
                     break;
-                case "exteral_sensor_source":
-                    await entity.write("hvacThermostat", { 1064: { value: value, type: zigbee_herdsman_1.Zcl.DataType.UINT16 } });
-                    break;
                 default: // Unknown key
                     throw new Error(`Unhandled key tzLocal.ctm_thermostat.convertSet ${key}`);
             }
@@ -585,46 +1029,28 @@ const tzLocal = {
         convertGet: async (entity, key, meta) => {
             switch (key) {
                 case "load":
-                    await entity.read("hvacThermostat", [0x0401]);
+                    await entity.read("hvacThermostat", ["ctmLoad"]);
                     break;
                 case "display_text":
-                    await entity.read("hvacThermostat", [0x0402]);
-                    break;
-                case "sensor":
-                    await entity.read("hvacThermostat", [0x0403]);
+                    await entity.read("hvacThermostat", ["ctmDisplayText"]);
                     break;
                 case "regulator_mode":
-                    await entity.read("hvacThermostat", [0x0405]);
+                    await entity.read("hvacThermostat", ["ctmRegulatorMode"]);
                     break;
                 case "power_status":
-                    await entity.read("hvacThermostat", [0x0406]);
-                    break;
-                case "night_switching":
-                    await entity.read("hvacThermostat", [0x0411]);
+                    await entity.read("hvacThermostat", ["ctmPowerStatus"]);
                     break;
                 case "frost_guard":
-                    await entity.read("hvacThermostat", [0x0412]);
-                    break;
-                case "max_floor_temp":
-                    await entity.read("hvacThermostat", [0x0414]);
+                    await entity.read("hvacThermostat", ["ctmFrostGuard"]);
                     break;
                 case "regulator_setpoint":
-                    await entity.read("hvacThermostat", [0x0420]);
+                    await entity.read("hvacThermostat", ["ctmRegulatorSetpoint"]);
                     break;
                 case "regulation_mode":
-                    await entity.read("hvacThermostat", [0x0421]);
+                    await entity.read("hvacThermostat", ["ctmRegulationMode"]);
                     break;
                 case "system_mode":
-                    await entity.read("hvacThermostat", [0x0422]);
-                    break;
-                case "max_floor_guard":
-                    await entity.read("hvacThermostat", [0x0423]);
-                    break;
-                case "weekly_timer":
-                    await entity.read("hvacThermostat", [0x0424]);
-                    break;
-                case "exteral_sensor_source":
-                    await entity.read("hvacThermostat", [0x0428]);
+                    await entity.read("hvacThermostat", ["ctmOperationMode"]);
                     break;
                 default: // Unknown key
                     throw new Error(`Unhandled key tzLocal.ctm_thermostat.convertGet ${key}`);
@@ -645,41 +1071,23 @@ const tzLocal = {
         },
     },
     ctm_thermostat_gets: {
-        key: [
-            "mean_power",
-            "floor_temp",
-            "running_state",
-            "frost_guard_setpoint",
-            "external_temp",
-            "air_temp",
-            "floor_sensor_error",
-            "exteral_sensor_error",
-        ],
+        key: ["mean_power", "floor_temp", "running_state", "external_temp", "air_temp"],
         convertGet: async (entity, key, meta) => {
             switch (key) {
                 case "mean_power":
-                    await entity.read("hvacThermostat", [0x0408]);
+                    await entity.read("hvacThermostat", ["ctmMeanPower"]);
                     break;
                 case "floor_temp":
-                    await entity.read("hvacThermostat", [0x0409]);
+                    await entity.read("hvacThermostat", ["ctmFloorTemp"]);
                     break;
                 case "running_state":
-                    await entity.read("hvacThermostat", [0x0415]);
-                    break;
-                case "frost_guard_setpoint":
-                    await entity.read("hvacThermostat", [0x0425]);
+                    await entity.read("hvacThermostat", ["ctmRelayState"]);
                     break;
                 case "external_temp":
-                    await entity.read("hvacThermostat", [0x0426]);
+                    await entity.read("hvacThermostat", ["ctmExternalTemp"]);
                     break;
                 case "air_temp":
-                    await entity.read("hvacThermostat", [0x0429]);
-                    break;
-                case "floor_sensor_error":
-                    await entity.read("hvacThermostat", [0x042b]);
-                    break;
-                case "exteral_sensor_error":
-                    await entity.read("hvacThermostat", [0x042c]);
+                    await entity.read("hvacThermostat", ["ctmAirTemp"]);
                     break;
                 default: // Unknown key
                     throw new Error(`Unhandled key tzLocal.ctm_thermostat.convertGet ${key}`);
@@ -689,96 +1097,32 @@ const tzLocal = {
     ctm_group_config: {
         key: ["group_id"],
         convertGet: async (entity, key, meta) => {
-            await entity.read(0xfea7, [0x0000], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+            await entity.read("ctmGroupConfig", ["groupId"], {
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            });
         },
     },
-    ctm_sove_guard: {
-        key: [
-            "alarm_status",
-            "change_battery",
-            "stove_temperature",
-            "ambient_temperature",
-            "active",
-            "runtime",
-            "runtime_timeout",
-            "reset_reason",
-            "dip_switch",
-            "sw_version",
-            "hw_version",
-            "bootloader_version",
-            "model",
-            "relay_address",
-            "current_flag",
-            "relay_current",
-            "relay_status",
-            "external_button",
-            "relay_alarm",
-            "relay_alarm_status",
-        ],
+    ctm_stove_guard: {
+        key: ["alarm_status", "change_battery", "active"],
         convertGet: async (entity, key, meta) => {
             switch (key) {
                 case "alarm_status":
-                    await entity.read(0xffc9, [0x0001], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+                    await entity.read("ctmStoveGuard", ["alarmStatus"], {
+                        manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+                    });
                     break;
                 case "battery_low":
-                    await entity.read(0xffc9, [0x0002], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "stove_temperature":
-                    await entity.read(0xffc9, [0x0003], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "ambient_temperature":
-                    await entity.read(0xffc9, [0x0004], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+                    await entity.read("ctmStoveGuard", ["batteryLow"], {
+                        manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+                    });
                     break;
                 case "active":
-                    await entity.read(0xffc9, [0x0005], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "runtime":
-                    await entity.read(0xffc9, [0x0006], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "runtime_timeout":
-                    await entity.read(0xffc9, [0x0007], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "reset_reason":
-                    await entity.read(0xffc9, [0x0008], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "dip_switch":
-                    await entity.read(0xffc9, [0x0009], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "sw_version":
-                    await entity.read(0xffc9, [0x000a], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "hw_version":
-                    await entity.read(0xffc9, [0x000b], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "bootloader_version":
-                    await entity.read(0xffc9, [0x000c], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "model":
-                    await entity.read(0xffc9, [0x000d], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "relay_address":
-                    await entity.read(0xffc9, [0x0010], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "current_flag":
-                    await entity.read(0xffc9, [0x0100], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "relay_current":
-                    await entity.read(0xffc9, [0x0101], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "relay_status":
-                    await entity.read(0xffc9, [0x0102], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "external_button":
-                    await entity.read(0xffc9, [0x0103], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "relay_alarm":
-                    await entity.read(0xffc9, [0x0104], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
-                    break;
-                case "relay_alarm_status":
-                    await entity.read(0xffc9, [0x0105], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+                    await entity.read("ctmStoveGuard", ["active"], {
+                        manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+                    });
                     break;
                 default: // Unknown key
-                    throw new Error(`Unhandled key tzLocal.ctm_sove_guard.convertGet ${key}`);
+                    throw new Error(`Unhandled key tzLocal.ctm_stove_guard.convertGet ${key}`);
             }
         },
     },
@@ -843,6 +1187,7 @@ exports.definitions = [
         model: "mTouch_Bryter",
         vendor: "CTM Lyng",
         description: "mTouch Bryter OP, 3 channel switch",
+        extend: [cluster.addCtmGroupConfigCluster()],
         fromZigbee: [
             fz.temperature,
             fz.battery,
@@ -862,7 +1207,9 @@ exports.definitions = [
             await reporting.batteryVoltage(endpoint);
             await endpoint.read("msTemperatureMeasurement", ["measuredValue"]);
             await reporting.temperature(endpoint, { min: constants.repInterval.MINUTES_10, max: constants.repInterval.HOUR, change: 100 });
-            await endpoint.read(0xfea7, [0x0000], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+            await endpoint.read("ctmGroupConfig", ["groupId"], {
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            });
         },
         exposes: [
             e.battery(),
@@ -878,6 +1225,7 @@ exports.definitions = [
         model: "mTouch_One",
         vendor: "CTM Lyng",
         description: "mTouch One OP, touch thermostat",
+        extend: [cluster.addCtmToHvacThermostatCluster()],
         fromZigbee: [fz.thermostat, fzLocal.ctm_thermostat],
         toZigbee: [
             tz.thermostat_occupied_heating_setpoint,
@@ -892,85 +1240,81 @@ exports.definitions = [
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ["hvacThermostat"]);
             await endpoint.read("hvacThermostat", ["localTemp", "occupiedHeatingSetpoint"]);
+            await endpoint.read("hvacThermostat", [
+                "ctmLoad",
+                "ctmDisplayText",
+                "ctmRegulatorMode",
+                "ctmMeanPower",
+                "ctmFloorTemp",
+            ]);
+            await endpoint.read("hvacThermostat", [
+                "ctmFrostGuard",
+                "ctmChildLock",
+                "ctmRegulatorSetpoint",
+                "ctmOperationMode",
+                "ctmAirTemp",
+            ]);
             await reporting.thermostatTemperature(endpoint);
             await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
-            await endpoint.read("hvacThermostat", [0x0401]);
-            await endpoint.read("hvacThermostat", [0x0402]);
-            // Regulator mode
-            await endpoint.read("hvacThermostat", [0x0405]);
             await endpoint.configureReporting("hvacThermostat", [
                 {
-                    attribute: { ID: 0x0405, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    attribute: "ctmRegulatorMode",
                     minimumReportInterval: 1,
                     maximumReportInterval: constants.repInterval.MAX,
                     reportableChange: null,
                 },
             ]);
-            // Power consumption
-            await endpoint.read("hvacThermostat", [0x0408]);
             await endpoint.configureReporting("hvacThermostat", [
                 {
-                    attribute: { ID: 0x0408, type: zigbee_herdsman_1.Zcl.DataType.UINT16 },
+                    attribute: "ctmMeanPower",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 5,
                 },
             ]);
-            // Floor temp sensor
-            await endpoint.read("hvacThermostat", [0x0409]);
             await endpoint.configureReporting("hvacThermostat", [
                 {
-                    attribute: { ID: 0x0409, type: zigbee_herdsman_1.Zcl.DataType.INT16 },
+                    attribute: "ctmFloorTemp",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 10,
                 },
             ]);
-            // Frost guard
-            await endpoint.read("hvacThermostat", [0x0412]);
             await endpoint.configureReporting("hvacThermostat", [
                 {
-                    attribute: { ID: 0x0412, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    attribute: "ctmFrostGuard",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.MAX,
                     reportableChange: null,
                 },
             ]);
-            // Child lock active/inactive
-            await endpoint.read("hvacThermostat", [0x0413]);
             await endpoint.configureReporting("hvacThermostat", [
                 {
-                    attribute: { ID: 0x0413, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    attribute: "ctmChildLock",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.MAX,
                     reportableChange: null,
                 },
             ]);
-            // Regulator setpoint
-            await endpoint.read("hvacThermostat", [0x0420]);
             await endpoint.configureReporting("hvacThermostat", [
                 {
-                    attribute: { ID: 0x0420, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    attribute: "ctmRegulatorSetpoint",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 1,
                 },
             ]);
-            // Operation mode
-            await endpoint.read("hvacThermostat", [0x0422]);
             await endpoint.configureReporting("hvacThermostat", [
                 {
-                    attribute: { ID: 0x0422, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    attribute: "ctmOperationMode",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 1,
                 },
             ]);
-            // Air temp sensor
-            await endpoint.read("hvacThermostat", [0x0429]);
             await endpoint.configureReporting("hvacThermostat", [
                 {
-                    attribute: { ID: 0x0429, type: zigbee_herdsman_1.Zcl.DataType.INT16 },
+                    attribute: "ctmAirTemp",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 10,
@@ -1099,39 +1443,36 @@ exports.definitions = [
         model: "mKomfy_Sensor",
         vendor: "CTM Lyng",
         description: "mKomfy, stove guard",
-        fromZigbee: [fz.temperature, fz.battery, fzLocal.ctm_sove_guard],
+        extend: [cluster.addCtmStoveGuardCluster()],
+        fromZigbee: [fz.temperature, fz.battery, fzLocal.ctm_stove_guard],
         toZigbee: [],
         configure: async (device, coordinatorEndpoint) => {
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ["genPowerCfg", "msTemperatureMeasurement", 0xffc9]);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genPowerCfg", "msTemperatureMeasurement", "ctmStoveGuard"]);
             await reporting.batteryPercentageRemaining(endpoint);
-            // await endpoint.read('msTemperatureMeasurement', ['measuredValue']);
             await reporting.temperature(endpoint, { min: constants.repInterval.MINUTES_10, max: constants.repInterval.HOUR, change: 100 });
             // Alarm status
-            // await endpoint.read(0xFFC9, [0x0001], {manufacturerCode: Zcl.ManufacturerCode.DATEK_WIRELESS_AS});
-            await endpoint.configureReporting(0xffc9, [
+            await endpoint.configureReporting("ctmStoveGuard", [
                 {
-                    attribute: { ID: 0x0001, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    attribute: "alarmStatus",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 0,
                 },
             ], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
             // Change battery
-            // await endpoint.read(0xFFC9, [0x0002], {manufacturerCode: Zcl.ManufacturerCode.DATEK_WIRELESS_AS});
-            await endpoint.configureReporting(0xffc9, [
+            await endpoint.configureReporting("ctmStoveGuard", [
                 {
-                    attribute: { ID: 0x0002, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    attribute: "batteryLow",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.MAX,
                     reportableChange: 0,
                 },
             ], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
             // Active
-            // await endpoint.read(0xFFC9, [0x0005], {manufacturerCode: Zcl.ManufacturerCode.DATEK_WIRELESS_AS});
-            await endpoint.configureReporting(0xffc9, [
+            await endpoint.configureReporting("ctmStoveGuard", [
                 {
-                    attribute: { ID: 0x0005, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    attribute: "active",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 0,
@@ -1153,6 +1494,7 @@ exports.definitions = [
         model: "mTouch_Astro",
         vendor: "CTM Lyng",
         description: "mTouch Astro OP, astro clock",
+        extend: [cluster.addCtmGroupConfigCluster(), cluster.addCtmGenOnOffCluster()],
         fromZigbee: [
             fz.on_off,
             fz.command_on,
@@ -1169,35 +1511,36 @@ exports.definitions = [
             await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff"]);
             await endpoint.read("genOnOff", ["onOff"]);
             await reporting.onOff(endpoint);
-            // Device mode
-            await endpoint.read("genOnOff", [0x2200]);
+            await endpoint.read("genOnOff", ["deviceMode"]);
             await endpoint.configureReporting("genOnOff", [
                 {
-                    attribute: { ID: 0x2200, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
+                    attribute: "deviceMode",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 0,
                 },
             ]);
-            await endpoint.read("genOnOff", [0x2201]);
+            await endpoint.read("genOnOff", ["deviceEnabled"]);
             await endpoint.configureReporting("genOnOff", [
                 {
-                    attribute: { ID: 0x2201, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    attribute: "deviceEnabled",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: null,
                 },
             ]);
-            await endpoint.read("genOnOff", [0x2202]);
+            await endpoint.read("genOnOff", ["childLock"]);
             await endpoint.configureReporting("genOnOff", [
                 {
-                    attribute: { ID: 0x2202, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    attribute: "childLock",
                     minimumReportInterval: 0,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: null,
                 },
             ]);
-            await endpoint.read(0xfea7, [0x0000], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+            await endpoint.read("ctmGroupConfig", ["groupId"], {
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            });
         },
         exposes: [
             e.switch(),
@@ -1259,6 +1602,7 @@ exports.definitions = [
         model: "mSwitch_Mic",
         vendor: "CTM Lyng",
         description: "Mikrofon, alarm detection microphone",
+        extend: [cluster.addCtmGroupConfigCluster()],
         fromZigbee: [fz.temperature, fz.battery, fz.command_on, fz.command_off, fz.ias_enroll, fz.ias_smoke_alarm_1, fzLocal.ctm_group_config],
         toZigbee: [],
         meta: { battery: { voltageToPercentage: { min: 2500, max: 3200 } } },
@@ -1269,7 +1613,9 @@ exports.definitions = [
             await endpoint.read("ssIasZone", ["iasCieAddr", "zoneState", "zoneId"]);
             await endpoint.read("msTemperatureMeasurement", ["measuredValue"]);
             await reporting.temperature(endpoint, { min: constants.repInterval.MINUTES_10, max: constants.repInterval.HOUR, change: 100 });
-            await endpoint.read(0xfea7, [0x0000], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+            await endpoint.read("ctmGroupConfig", ["groupId"], {
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            });
         },
         exposes: [
             e.temperature(),
@@ -1317,11 +1663,12 @@ exports.definitions = [
             await reporting.onOff(endpoint);
             await endpoint.read("msOccupancySensing", ["occupancy"]);
             await reporting.occupancy(endpoint);
-            // Relay State
-            await endpoint.read("genOnOff", [0x5001], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+            await endpoint.read("genOnOff", ["relayState"], {
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            });
             await endpoint.configureReporting("genOnOff", [
                 {
-                    attribute: { ID: 0x5001, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    attribute: "relayState",
                     minimumReportInterval: 1,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 0,
@@ -1329,7 +1676,7 @@ exports.definitions = [
             ], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
         },
         exposes: [e.switch(), e.occupancy(), e.binary("device_enabled", ea.ALL, "ON", "OFF").withDescription("Turn the device on or off")],
-        extend: [m.illuminance()],
+        extend: [cluster.addCtmGenOnOffCluster(), m.illuminance()],
     },
     {
         zigbeeModel: ["MBD Dim"],
@@ -1374,10 +1721,12 @@ exports.definitions = [
             await endpoint.read("msOccupancySensing", ["occupancy"]);
             await reporting.occupancy(endpoint);
             // Relay State
-            await endpoint.read("genOnOff", [0x5001], { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS });
+            await endpoint.read("genOnOff", ["relayState"], {
+                manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.DATEK_WIRELESS_AS,
+            });
             await endpoint.configureReporting("genOnOff", [
                 {
-                    attribute: { ID: 0x5001, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
+                    attribute: "relayState",
                     minimumReportInterval: 1,
                     maximumReportInterval: constants.repInterval.HOUR,
                     reportableChange: 0,
@@ -1396,7 +1745,7 @@ exports.definitions = [
                 .withValueMax(97)
                 .withDescription('Specifies the initialisation light level. Can not be set lower than "ballast_minimum_level"'),
         ],
-        extend: [m.illuminance()],
+        extend: [cluster.addCtmGenOnOffCluster(), m.illuminance()],
     },
     {
         fingerprint: [{ modelID: "DIMMER", manufacturerName: "NorLum Dim OP" }],