@willieee802/zigbee-herdsman-converters 19.44.3 → 19.45.0

package/dist/lib/tuya.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clusters = exports.modernExtend = exports.fz = exports.tz = exports.valueConverter = exports.valueConverterBasic = exports.Bitmap = exports.BacklightColorEnum = exports.enum = exports.Enum = exports.whitelabel = exports.fingerprint = exports.configureBindBasic = exports.configureMcuVersionRequest = exports.configureQuery = exports.configureMagicPacket = exports.skip = exports.exposes = exports.TuyaWeatherID = exports.F3ProTuyaWeatherCondition = exports.M8ProTuyaWeatherCondition = exports.dataTypes = void 0;
+exports.clusters = exports.modernExtend = exports.fz = exports.tz = exports.valueConverter = exports.valueConverterBasic = exports.Bitmap = exports.BacklightColorEnum = exports.enum = exports.Enum = exports.whitelabel = exports.fingerprint = exports.configureBindBasic = exports.configureMcuVersionRequest = exports.configureQuery = exports.configureMagicPacket = exports.skip = exports.exposes = exports.TuyaWeatherID = exports.F3ProTuyaWeatherCondition = exports.M8ProTuyaWeatherCondition = exports.dataTypes = exports.circuitBreakerFaultList = void 0;
 exports.convertBufferToNumber = convertBufferToNumber;
 exports.convertDecimalValueTo4ByteHexArray = convertDecimalValueTo4ByteHexArray;
 exports.dpValueFromString = dpValueFromString;
@@ -47,6 +47,7 @@ exports.getHandlersForDP = getHandlersForDP;
 const zigbee_herdsman_1 = require("@willieee802/zigbee-herdsman");
 const fz = __importStar(require("../converters/fromZigbee"));
 const tz = __importStar(require("../converters/toZigbee"));
+const libColor = __importStar(require("../lib/color"));
 const constants = __importStar(require("./constants"));
 const exposes = __importStar(require("./exposes"));
 const logger_1 = require("./logger");
@@ -58,6 +59,25 @@ const utils_1 = require("./utils");
 const NS = "zhc:tuya";
 const e = exposes.presets;
 const ea = exposes.access;
+exports.circuitBreakerFaultList = [
+    "short_circuit",
+    "surge",
+    "overload",
+    "leakage_current",
+    "temperature",
+    "fire",
+    "high_power",
+    "self_test",
+    "over_current",
+    "unbalance",
+    "over_voltage",
+    "under_voltage",
+    "miss_phase",
+    "outage",
+    "magnetism", // or negative_power
+    "credit",
+    "no_balance",
+];
 exports.dataTypes = {
     raw: 0, // [ bytes ]
     bool: 1, // [0/1]
@@ -234,6 +254,15 @@ async function sendDataPointStringBuffer(entity, dp, value, cmd, seq) {
     return await sendDataPoints(entity, [dpValueFromString(dp, value)], cmd, seq);
 }
 const tuyaExposes = {
+    alarmTime: () => e
+        .numeric("alarm_time", ea.STATE_SET)
+        .withUnit("s")
+        .withValueMin(1)
+        .withValueMax(180)
+        .withValueStep(1)
+        .withDescription("Alarm time")
+        .withCategory("config"),
+    alarmMode: () => e.enum("alarm_mode", ea.STATE_SET, ["arm", "silent", "disarm"]).withDescription("Alarm work mode").withCategory("config"),
     lightType: () => e.enum("light_type", ea.STATE_SET, ["led", "incandescent", "halogen"]).withDescription("Type of light attached to the device"),
     lightBrightnessWithMinMax: () => e
         .light_brightness()
@@ -250,10 +279,50 @@ const tuyaExposes = {
         .withValueMax(43200)
         .withValueStep(1)
         .withUnit("s")
-        .withDescription("Countdown to turn device off after a certain time"),
+        .withDescription("Toggle the device after a set duration (one time action)"),
+    countdown_min: () => e
+        .numeric("countdown", ea.STATE_SET)
+        .withValueMin(1)
+        .withValueMax(240)
+        .withValueStep(1)
+        .withUnit("min")
+        .withDescription("Turn off the sprinkler after set duration (one time action)"),
+    on_with_countdown: () => e
+        .numeric("on_with_countdown", ea.STATE_SET)
+        .withValueMin(1)
+        .withValueMax(240)
+        .withValueStep(1)
+        .withUnit("min")
+        .withDescription("Turn on the sprinkler and start countdown"),
+    countdown_left: () => e
+        .numeric("countdown_left", ea.STATE)
+        .withValueMin(0)
+        .withValueMax(240)
+        .withValueStep(1)
+        .withUnit("min")
+        .withDescription("Time left in the countdown"),
+    single_watering_duration: () => e.numeric("single_watering_duration", ea.STATE).withDescription("Duration of last watering").withUnit("s"),
+    flow_switch: () => e
+        .binary("flow_switch", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Enables water flow measurement, and automatically turn off the sprinkler when flow is 0 for ~30s"),
+    quantitative_watering: () => e
+        .numeric("quantitative_watering", ea.STATE_SET)
+        .withValueMin(1)
+        .withValueMax(10000)
+        .withValueStep(1)
+        .withUnit("L")
+        .withDescription("Turn on the sprinkler with a set amount of water"),
+    single_watering_amount: () => e.numeric("single_watering_amount", ea.STATE).withUnit("L").withDescription("Quantity of last watering"),
+    surplus_flow: () => e.numeric("surplus_flow", ea.STATE).withUnit("L").withDescription("Remaining amount"),
+    water_total: () => e.numeric("water_total", ea.STATE).withUnit("L").withValueMin(0).withValueStep(0.001).withDescription("Total watering amount"),
+    water_current: () => e.numeric("water_current", ea.STATE).withUnit("L/min").withValueMin(0).withValueStep(0.001).withDescription("Current water flow"),
+    water_total_reset: () => e.enum("water_total_reset", ea.STATE_SET, ["reset"]).withDescription("Reset the stored watering amount to 0").withCategory("config"),
+    refresh: () => e.enum("refresh", ea.STATE_SET, ["refresh"]).withDescription("Refresh the device status").withCategory("config"),
+    status_sprinkler: () => e.enum("status", ea.STATE, ["off", "on_auto", "button_locked", "on_manual_app", "on_manual_button"]).withDescription("Status"),
     switch: () => e.switch().setAccess("state", ea.STATE_SET),
     selfTest: () => e.binary("self_test", ea.STATE_SET, true, false).withDescription("Indicates whether the device is being self-tested"),
     selfTestResult: () => e.enum("self_test_result", ea.STATE, ["checking", "success", "failure", "others"]).withDescription("Result of the self-test"),
+    fault: () => e.binary("fault", ea.STATE, true, false).withDescription("Indicates whether a fault was detected").withCategory("diagnostic"),
     faultAlarm: () => e.binary("fault_alarm", ea.STATE, true, false).withDescription("Indicates whether a fault was detected"),
     silence: () => e.binary("silence", ea.STATE_SET, true, false).withDescription("Silence the alarm"),
     frostProtection: (extraNote = "") => e
@@ -335,7 +404,7 @@ const tuyaExposes = {
     batteryState: () => e.enum("battery_state", ea.STATE, ["low", "medium", "high"]).withDescription("State of the battery"),
     doNotDisturb: () => e
         .binary("do_not_disturb", ea.STATE_SET, true, false)
-        .withDescription("Do not disturb mode, when enabled this function will keep the light OFF after a power outage")
+        .withDescription("Controls state after power outage: false = on, true = restore previous state")
         .withCategory("config"),
     colorPowerOnBehavior: () => e
         .enum("color_power_on_behavior", ea.STATE_SET, ["initial", "previous", "customized"])
@@ -378,6 +447,266 @@ const tuyaExposes = {
         }
         return x;
     },
+    inchingSwitch2: () => e
+        .composite("inching", "inching", ea.STATE_SET)
+        .withDescription("Inching configuration")
+        .withFeature(e
+        .binary("state", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Whenever the device is switched ON, switch it OFF automatically after the configured delay"))
+        .withFeature(e
+        .numeric("minutes", ea.STATE_SET)
+        .withUnit("m")
+        .withValueMin(0)
+        .withValueMax(1440)
+        .withDescription("Minutes component of the delay duration"))
+        .withFeature(e
+        .numeric("seconds", ea.STATE_SET)
+        .withUnit("s")
+        .withValueMin(0)
+        .withValueMax(59)
+        .withDescription("Seconds component of the delay duration"))
+        .withCategory("config"),
+    circuitBreakerFaults: () => e
+        .list("faults", ea.STATE, e.enum("fault", ea.STATE, exports.circuitBreakerFaultList))
+        .withDescription("List of current faults")
+        .withCategory("diagnostic"),
+    circuitBreakerStatus: () => e.enum("status", ea.STATE, ["off", "consumption", "production"]).withDescription("Current operating status").withCategory("diagnostic"),
+    leakageCurrent: () => e
+        .numeric("leakage_current", ea.STATE)
+        .withUnit("mA")
+        .withDescription("Measured current difference between live and neutral wires")
+        .withCategory("diagnostic"),
+    reclosing: () => e
+        .binary("reclosing", ea.STATE_SET, "ON", "OFF")
+        .withCategory("config")
+        .withDescription("Automatically attempt switching ON the circuit after it was turned OFF by a detected fault"),
+    reclosing_delay: () => e
+        .numeric("reclosing_delay", ea.STATE_SET)
+        .withUnit("s")
+        .withValueMin(1)
+        .withValueMax(99)
+        .withValueStep(1)
+        .withCategory("config")
+        .withDescription("Time to wait after the fault is cleared, before attempting reclose"),
+    reclosing_count: () => e
+        .numeric("reclosing_count", ea.STATE_SET)
+        .withValueMin(0)
+        .withValueMax(30)
+        .withValueStep(1)
+        .withCategory("config")
+        .withDescription("Number of allowed reclosing attempts per fault"),
+    energyPrepayment: () => e
+        .binary("prepayment", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Automatically switch OFF the circuit when the energy balance reaches zero")
+        .withCategory("config"),
+    energyBalance: () => e
+        .numeric("energy_balance", ea.STATE)
+        .withUnit("kWh")
+        .withDescription("Amount of energy allowed for consumption (Decreases when Prepayment is enabled)")
+        .withCategory("diagnostic"),
+    energyBalanceAdd: () => e
+        .numeric("energy_balance_add", ea.STATE_SET)
+        .withUnit("kWh")
+        .withValueMin(0)
+        .withValueMax(999999)
+        .withValueStep(0.01)
+        .withDescription("Add an amount of energy to the balance")
+        .withCategory("config"),
+    energyBalanceReset: () => e.enum("energy_balance_reset", ea.STATE_SET, ["RESET"]).withDescription("Set the energy balance to zero").withCategory("config"),
+    energyReset: () => e.enum("energy_reset", ea.STATE_SET, ["RESET"]).withDescription("Set the energy measurements to zero").withCategory("config"),
+    leakageCurrentAndTemperatureAlarm: () => e
+        .composite("alarm_set_1", "alarm_set_1", ea.STATE_SET)
+        .withDescription("Leakage current and temperature alarms configuration")
+        .withFeature(e
+        .binary("leakage_current_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Automatically switch OFF the circuit when the leakage current is above the limit (Default ON)"))
+        .withFeature(e
+        .numeric("leakage_current_threshold", ea.STATE_SET)
+        .withUnit("mA")
+        .withValueMin(1)
+        .withValueMax(99)
+        .withValueStep(1)
+        .withDescription("Leakage current limit (Default 50mA)"))
+        .withFeature(e
+        .binary("device_temperature_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Automatically switch OFF the circuit when the measured temperature exceeds the limit (Default ON)"))
+        .withFeature(e
+        .numeric("device_temperature_threshold", ea.STATE_SET)
+        .withUnit("°C")
+        .withValueMin(10)
+        .withValueMax(85)
+        .withValueStep(1)
+        .withDescription("Temperature limit (Default 80°C)"))
+        .withCategory("config"),
+    rs485ConfigAndHighPowerAlarm: () => e
+        .composite("alarm_set_1", "alarm_set_1", ea.STATE_SET)
+        .withDescription("Configuration for RS485 wired communication (if supported by device) and high power alarm")
+        .withFeature(e.binary("rs485_baud_rate_enabled", ea.STATE_SET, "ON", "OFF").withLabel("RS485 baud rate"))
+        .withFeature(e.enum("rs485_baud_rate", ea.STATE_SET, [2400, 4800, 9600, 19200, 38400]).withLabel("RS485 baud rate"))
+        .withFeature(e.binary("rs485_address_enabled", ea.STATE_SET, "ON", "OFF").withLabel("RS485 address"))
+        .withFeature(e.numeric("rs485_address", ea.STATE_SET).withValueMin(1).withValueMax(100).withValueStep(1).withLabel("RS485 address"))
+        .withFeature(e.binary("rs485_data_format_enabled", ea.STATE_SET, "ON", "OFF").withLabel("RS485 data format"))
+        .withFeature(e.enum("rs485_data_format", ea.STATE_SET, ["N81", "E81", "O81", "N82"]).withLabel("RS485 data format"))
+        .withFeature(e
+        .binary("high_power_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Trigger alarm when power draw exceeds the limit (Default OFF)"))
+        .withFeature(e
+        .numeric("high_power_threshold", ea.STATE_SET)
+        .withValueMin(0)
+        .withValueMax(65535)
+        .withValueStep(1)
+        .withUnit("kW")
+        .withDescription("Power limit (Default 25 kW)"))
+        .withCategory("config"),
+    currentAndVoltageAlarm: () => e
+        .composite("alarm_set_2", "alarm_set_2", ea.STATE_SET)
+        .withDescription("Current and voltage alarms configuration")
+        .withFeature(e
+        .binary("over_current_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Automatically switch OFF the circuit when the circuit draws more current than the limit (Default ON)"))
+        .withFeature(e
+        .numeric("over_current_threshold", ea.STATE_SET)
+        .withUnit("A")
+        .withValueMin(1.0)
+        .withValueMax(80.0)
+        .withValueStep(0.1)
+        .withDescription("Current upper limit (Default 63A)"))
+        .withFeature(e
+        .binary("over_voltage_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Automatically switch OFF the circuit when the voltage is above the limit (Default ON)"))
+        .withFeature(e
+        .numeric("over_voltage_threshold", ea.STATE_SET)
+        .withUnit("V")
+        .withValueMin(120)
+        .withValueMax(300)
+        .withValueStep(1)
+        .withDescription("Voltage upper limit (Default 275V)"))
+        .withFeature(e
+        .binary("under_voltage_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Automatically switch OFF the circuit when the voltage is below the limit (Default ON)"))
+        .withFeature(e
+        .numeric("under_voltage_threshold", ea.STATE_SET)
+        .withUnit("V")
+        .withValueMin(80)
+        .withValueMax(210)
+        .withValueStep(1)
+        .withDescription("Voltage lower limit (Default 175V)"))
+        .withCategory("config"),
+    alarmSet2: () => e
+        .composite("alarm_set_2", "alarm_set_2", ea.STATE_SET)
+        .withDescription("Configuration for alarms and reporting frequency")
+        .withFeature(e
+        .binary("over_current_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Trigger alarm when current is higher than the limit (Default OFF)"))
+        .withFeature(e
+        .numeric("over_current_threshold", ea.STATE_SET)
+        .withUnit("A")
+        .withValueMin(0)
+        .withValueMax(65535)
+        .withValueStep(1)
+        .withDescription("Current upper limit (Default 100A)"))
+        .withFeature(e
+        .binary("over_voltage_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Trigger alarm when the voltage is above the limit (Default ON)"))
+        .withFeature(e
+        .numeric("over_voltage_threshold", ea.STATE_SET)
+        .withUnit("V")
+        .withValueMin(0)
+        .withValueMax(65535)
+        .withValueStep(1)
+        .withDescription("Voltage upper limit (Default 253V)"))
+        .withFeature(e
+        .binary("under_voltage_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Trigger alarm when the voltage is below the limit (Default OFF)"))
+        .withFeature(e
+        .numeric("under_voltage_threshold", ea.STATE_SET)
+        .withUnit("V")
+        .withValueMin(0)
+        .withValueMax(65535)
+        .withValueStep(1)
+        .withDescription("Voltage lower limit (Default 180V)"))
+        .withFeature(e
+        .binary("unbalanced_load_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Trigger alarm when power factor is below the limit (Default 15%)"))
+        .withFeature(e
+        .numeric("unbalanced_load_threshold", ea.STATE_SET)
+        .withUnit("%")
+        .withValueMin(0)
+        .withValueMax(100)
+        .withValueStep(1)
+        .withDescription("Power factor lower limit (Default 15%)"))
+        .withFeature(e.binary("phase_loss_alarm", ea.STATE_SET, "ON", "OFF").withDescription("Trigger alarm when one phase is unavailable (Default OFF)"))
+        .withFeature(e
+        .binary("negative_active_power_alarm", ea.STATE_SET, "ON", "OFF")
+        .withDescription("Trigger alarm when the active power is negative (Default ON)"))
+        .withFeature(e.binary("custom_data_reporting_interval", ea.STATE_SET, "ON", "OFF"))
+        .withFeature(e
+        .numeric("data_reporting_interval", ea.STATE_SET)
+        .withUnit("s")
+        .withValueMin(5)
+        .withValueMax(600)
+        .withValueStep(0.5)
+        .withDescription("How often the device should report measurements (Default 5s)"))
+        .withCategory("config"),
+    overCurrentThresholdTime: () => e
+        .numeric("over_current_threshold_time", ea.STATE_SET)
+        .withUnit("s")
+        .withValueMin(0)
+        .withValueMax(999)
+        .withValueStep(1)
+        .withDescription("Time overcurrent is allowed before the circuit is switched OFF (Default 0s)")
+        .withCategory("config"),
+    lostFlowAlarm: () => e
+        .composite("alarm_set_3", "alarm_set_3", ea.STATE_SET)
+        .withDescription("Lost flow alarm configuration")
+        .withFeature(e.binary("lost_flow_alarm", ea.STATE_SET, "ON", "OFF").withDescription("Unknown"))
+        .withFeature(e
+        .numeric("lost_flow_threshold", ea.STATE_SET)
+        .withUnit("A")
+        .withValueMin(1.0)
+        .withValueMax(100.0)
+        .withValueStep(0.1)
+        .withDescription("Unknown"))
+        .withCategory("config"),
+    lostFlowThresholdTime: () => e
+        .numeric("lost_flow_threshold_time", ea.STATE_SET)
+        .withUnit("s")
+        .withValueMin(0)
+        .withValueMax(999)
+        .withValueStep(1)
+        .withDescription("Unknown (Default 0s)")
+        .withCategory("config"),
+    liquidLevelPercent: () => e.numeric("liquid_level_percent", ea.STATE).withUnit("%").withDescription("Liquid level ratio"),
+    liquidDepth: () => e.numeric("liquid_depth", ea.STATE).withUnit("cm").withDescription("Liquid depth"),
+    liquidDepthMax: () => e
+        .numeric("liquid_depth_max", ea.STATE_SET)
+        .withUnit("mm")
+        .withDescription("Height from sensor to liquid level")
+        .withValueMin(10)
+        .withValueMax(4000)
+        .withValueStep(5),
+    liquidInstallationHeight: () => e
+        .numeric("installation_height", ea.STATE_SET)
+        .withUnit("mm")
+        .withDescription("Height from sensor to tank bottom")
+        .withValueMin(10)
+        .withValueMax(4000)
+        .withValueStep(5),
+    liquidMinimalPercent: () => e
+        .numeric("min_set", ea.STATE_SET)
+        .withUnit("%")
+        .withDescription("Liquid minimal percentage")
+        .withValueMin(0)
+        .withValueMax(100)
+        .withValueStep(1),
+    liquidMaximalPercent: () => e
+        .numeric("max_set", ea.STATE_SET)
+        .withUnit("%")
+        .withDescription("Liquid maximum percentage")
+        .withValueMin(0)
+        .withValueMax(100)
+        .withValueStep(1),
+    liquidState: () => e.enum("liquid_state", ea.STATE, ["low", "normal", "high"]).withDescription("Liquid level status"),
 };
 exports.exposes = tuyaExposes;
 exports.skip = {
@@ -423,6 +752,104 @@ const whitelabel = (vendor, model, description, manufacturerNames) => {
     return { vendor, model, description, fingerprint };
 };
 exports.whitelabel = whitelabel;
+function parseThresholds(buffer, definitions) {
+    const onOffLookup = { 0: "OFF", 1: "ON" };
+    const result = {};
+    for (let i = 0; i < buffer.length; i += 4) {
+        const id = buffer[i];
+        const definition = definitions[id];
+        if (!definition) {
+            continue;
+        }
+        result[definition.enabled] = onOffLookup[buffer[i + 1]];
+        if (definition.value)
+            result[definition.value] = buffer.readUInt16BE(i + 2);
+    }
+    return result;
+}
+function encodeThresholds(values, currentState, definitions) {
+    const onOffLookup = { OFF: 0, ON: 1 };
+    const result = [];
+    for (const [id, definition] of Object.entries(definitions)) {
+        const enabled = values[definition.enabled] ?? currentState[definition.enabled];
+        const value = !definition.value ? 0 : (values[definition.value] ?? currentState[definition.value]);
+        if (enabled === undefined || value === undefined) {
+            continue;
+        }
+        const buf = Buffer.alloc(4);
+        buf.writeUInt8(Number(id), 0);
+        buf.writeUInt8(utils.getFromLookup(enabled, onOffLookup), 1);
+        buf.writeUInt16BE(Number(value), 2);
+        result.push(...buf);
+    }
+    return result;
+}
+const alarmSet1ThresholdDefinitions = {
+    4: {
+        enabled: "leakage_current_alarm",
+        value: "leakage_current_threshold",
+    },
+    5: {
+        enabled: "device_temperature_alarm",
+        value: "device_temperature_threshold",
+    },
+};
+const alarmSet1BThresholdDefinitions = {
+    3: {
+        enabled: "rs485_baud_rate_enabled",
+        value: "rs485_baud_rate",
+    },
+    4: {
+        enabled: "rs485_address_enabled",
+        value: "rs485_address",
+    },
+    5: {
+        enabled: "rs485_data_format_enabled",
+        value: "rs485_data_format",
+    },
+    7: {
+        enabled: "high_power_alarm",
+        value: "high_power_threshold",
+    },
+};
+const alarmSet2ThresholdDefinitions = {
+    1: {
+        enabled: "over_current_alarm",
+        value: "over_current_threshold",
+    },
+    2: {
+        enabled: "unbalanced_load_alarm",
+        value: "unbalanced_load_threshold",
+    },
+    3: {
+        enabled: "over_voltage_alarm",
+        value: "over_voltage_threshold",
+    },
+    4: {
+        enabled: "under_voltage_alarm",
+        value: "under_voltage_threshold",
+    },
+    5: {
+        enabled: "phase_loss_alarm",
+    },
+    7: {
+        enabled: "negative_active_power_alarm",
+    },
+    8: {
+        enabled: "custom_data_reporting_interval",
+        value: "data_reporting_interval",
+    },
+    9: {
+        enabled: "device_locating",
+        value: "device_locating_threshold",
+    },
+};
+const alarmSet3ThresholdDefinitions = {
+    3: {
+        enabled: "lost_flow_alarm",
+        value: "lost_flow_threshold",
+    },
+};
 class Base {
     value;
     constructor(value) {
@@ -478,6 +905,9 @@ exports.valueConverterBasic = {
     divideBy: (value) => {
         return { to: (v) => v * value, from: (v) => v / value };
     },
+    multiplyBy: (value) => {
+        return { to: (v) => v / value, from: (v) => v * value };
+    },
     divideByFromOnly: (value) => {
         return { to: (v) => v, from: (v) => v / value };
     },
@@ -501,6 +931,8 @@ exports.valueConverter = {
     trueFalseEnum0: exports.valueConverterBasic.trueFalse(new Enum(0)),
     trueFalseEnum1: exports.valueConverterBasic.trueFalse(new Enum(1)),
     onOff: exports.valueConverterBasic.lookup({ ON: true, OFF: false }),
+    onOffEnumOn1: exports.valueConverterBasic.lookup({ ON: new Enum(1), OFF: new Enum(0) }),
+    onOffEnumOn0: exports.valueConverterBasic.lookup({ ON: new Enum(0), OFF: new Enum(1) }),
     powerOnBehavior: exports.valueConverterBasic.lookup({ off: 0, on: 1, previous: 2 }),
     powerOnBehaviorEnum: exports.valueConverterBasic.lookup({ off: new Enum(0), on: new Enum(1), previous: new Enum(2) }),
     switchType: exports.valueConverterBasic.lookup({ momentary: new Enum(0), toggle: new Enum(1), state: new Enum(2) }),
@@ -528,11 +960,14 @@ exports.valueConverter = {
     divideBy10: exports.valueConverterBasic.divideBy(10),
     divideBy100: exports.valueConverterBasic.divideBy(100),
     divideBy1000: exports.valueConverterBasic.divideBy(1000),
+    multiplyBy10: exports.valueConverterBasic.multiplyBy(10),
     divideBy10FromOnly: exports.valueConverterBasic.divideByFromOnly(10),
     switchMode: exports.valueConverterBasic.lookup({ switch: new Enum(0), scene: new Enum(1) }),
     switchMode2: exports.valueConverterBasic.lookup({ switch: new Enum(0), curtain: new Enum(1) }),
     lightMode: exports.valueConverterBasic.lookup({ normal: new Enum(0), on: new Enum(1), off: new Enum(2), flash: new Enum(3) }),
     raw: exports.valueConverterBasic.raw(),
+    fault: { from: (v) => !!v },
+    alarmMode: exports.valueConverterBasic.lookup({ arm: new Enum(0), silent: new Enum(1), disarm: new Enum(2) }),
     localTemperatureCalibration: {
         from: (value) => (value > 4000 ? value - 4096 : value),
         to: (value) => (value < 0 ? 4096 + value : value),
@@ -542,6 +977,14 @@ exports.valueConverter = {
         from: (value) => (value > 200 ? value - 256 : value),
         to: (value) => (value < 0 ? 256 + value : value),
     },
+    refresh: {
+        to: (v) => {
+            return v === "refresh";
+        },
+        from: () => {
+            return "idle";
+        },
+    },
     waterConsumption: {
         from: (v) => {
             const buf = Buffer.isBuffer(v) ? v : Buffer.from(v || []);
@@ -552,6 +995,19 @@ exports.valueConverter = {
             return 0;
         },
     },
+    fertility: exports.valueConverterBasic.lookup({
+        normal: new Enum(0),
+        lower: new Enum(1),
+        low: new Enum(2),
+        middle: new Enum(3),
+        high: new Enum(4),
+        higher: new Enum(5),
+    }),
+    temperature_humidity_alarm: exports.valueConverterBasic.lookup({
+        lower_alarm: new Enum(0),
+        upper_alarm: new Enum(1),
+        cancel: new Enum(2),
+    }),
     setLimit: {
         to: (v) => {
             if (!v)
@@ -632,6 +1088,49 @@ exports.valueConverter = {
             };
         },
     },
+    phaseVariant4: {
+        from: (v) => {
+            return {
+                voltage: v.readUint16BE(0) / 10,
+                current: ((v.readUint8(2) << 16) + (v.readUint8(3) << 8) + v.readUint8(4)) / 1000,
+                power: (v.readUint8(5) << 16) + (v.readUint8(6) << 8) + v.readUint8(7),
+            };
+        },
+    },
+    onOffWithZeros: {
+        to: (v) => {
+            if (v === "OFF")
+                return false;
+            if (v === "ON")
+                return true;
+        },
+        from: (v, meta, options, publish) => {
+            let result = "ON";
+            if (!v) {
+                // device is slow to report, we can assume zero values when off
+                publish({ status: "off", current: 0, power: 0 });
+                result = "OFF";
+            }
+            // setting/changing the state resets the countdown, but device doesn't report it
+            if (meta.state.state !== result)
+                publish({ countdown: 0 });
+            return result;
+        },
+    },
+    onOffFingerbot: {
+        to: (v) => {
+            if (v === "OFF")
+                return false;
+            if (v === "ON")
+                return true;
+        },
+        from: (v, meta, options, publish) => {
+            publish({ switch_states: "idle" });
+            if (v)
+                return "ON";
+            return "OFF";
+        },
+    },
     power: {
         from: (v) => {
             // Support negative readings
@@ -826,6 +1325,80 @@ exports.valueConverter = {
             return result;
         },
     },
+    threshold_4: {
+        from: (v) => parseThresholds(v, alarmSet1ThresholdDefinitions),
+        to: (v, meta) => encodeThresholds(v, meta.state.alarm_set_1 || {}, alarmSet1ThresholdDefinitions),
+    },
+    threshold_5: {
+        from: (v) => {
+            const result = parseThresholds(v, alarmSet2ThresholdDefinitions);
+            if (result["over_current_threshold"]) {
+                result["over_current_threshold"] = Number(result["over_current_threshold"]) / 10;
+            }
+            return result;
+        },
+        to: (v, meta) => {
+            const vEncoded = { ...v };
+            if (v["over_current_threshold"]) {
+                vEncoded["over_current_threshold"] = Number(v["over_current_threshold"] * 10);
+            }
+            return encodeThresholds(vEncoded, meta.state.alarm_set_2 || {}, alarmSet2ThresholdDefinitions);
+        },
+    },
+    threshold_6: {
+        from: (v) => {
+            const result = parseThresholds(v, alarmSet3ThresholdDefinitions);
+            if (result["lost_flow_threshold"]) {
+                result["lost_flow_threshold"] = Number(result["lost_flow_threshold"]) / 10;
+            }
+            return result;
+        },
+        to: (v, meta) => {
+            const vEncoded = { ...v };
+            if (v["lost_flow_threshold"]) {
+                vEncoded["lost_flow_threshold"] = Number(v["lost_flow_threshold"] * 10);
+            }
+            return encodeThresholds(vEncoded, meta.state.alarm_set_3 || {}, alarmSet3ThresholdDefinitions);
+        },
+    },
+    threshold_7: {
+        from: (v) => {
+            const result = parseThresholds(v, alarmSet1BThresholdDefinitions);
+            if (result["rs485_baud_rate"]) {
+                result["rs485_baud_rate"] = 1200 * 2 ** Number(result["rs485_baud_rate"]);
+            }
+            if (result["rs485_data_format"]) {
+                result["rs485_data_format"] = utils.getFromLookup(result["rs485_data_format"], { 81: "N81", 82: "E81", 83: "O81", 84: "N82" });
+            }
+            return result;
+        },
+        to: (v, meta) => {
+            const vEncoded = { ...v };
+            if (v["rs485_baud_rate"]) {
+                vEncoded["rs485_baud_rate"] = Math.log2(Number(v["rs485_baud_rate"]) / 1200);
+            }
+            if (v["rs485_data_format"]) {
+                vEncoded["rs485_data_format"] = utils.getFromLookup(v["rs485_data_format"], { N81: 81, E81: 82, O81: 83, N82: 84 });
+            }
+            return encodeThresholds(vEncoded, meta.state.alarm_set_1 || {}, alarmSet1BThresholdDefinitions);
+        },
+    },
+    threshold_8: {
+        from: (v) => {
+            const result = parseThresholds(v, alarmSet2ThresholdDefinitions);
+            if (result["data_reporting_interval"]) {
+                result["data_reporting_interval"] = Number(result["data_reporting_interval"]) / 2;
+            }
+            return result;
+        },
+        to: (v, meta) => {
+            const vEncoded = { ...v };
+            if (v["data_reporting_interval"]) {
+                vEncoded["data_reporting_interval"] = Number(v["data_reporting_interval"] * 2);
+            }
+            return encodeThresholds(vEncoded, meta.state.alarm_set_2 || {}, alarmSet2ThresholdDefinitions);
+        },
+    },
     selfTestResult: exports.valueConverterBasic.lookup({ checking: 0, success: 1, failure: 2, others: 3 }),
     lockUnlock: exports.valueConverterBasic.lookup({ LOCK: true, UNLOCK: false }),
     localTempCalibration1: {
@@ -864,6 +1437,34 @@ exports.valueConverter = {
             return v;
         },
     },
+    localTempCalibration4: {
+        from: (v) => {
+            if (v > 0x7fffffff)
+                v -= 0x100000000;
+            return v / 100;
+        },
+        to: (v) => {
+            if (v > 0)
+                return v * 100;
+            if (v < 0)
+                return v * 100 + 0x100000000;
+            return v;
+        },
+    },
+    localTempCalibration5: {
+        from: (v) => {
+            if (v > 0x7fffffff)
+                v -= 0x100000000;
+            return v;
+        },
+        to: (v) => {
+            if (v > 0)
+                return v;
+            if (v < 0)
+                return v + 0x100000000;
+            return v;
+        },
+    },
     thermostatHolidayStartStop: {
         from: (v) => {
             const start = {
@@ -893,7 +1494,7 @@ exports.valueConverter = {
     thermostatHolidayStartStopUnixTS: {
         // converts 8-byte big-endian 2 times Unix timestamps array to "YYYY/MM/DD HH:MM | YYYY/MM/DD HH:MM" string
         from: (v) => {
-            if (!v || v.length !== 8)
+            if (v?.length !== 8)
                 return "";
             // Convert first 4 bytes → start Unix timestamp
             const startUnixTS = (v[0] << 24) | (v[1] << 16) | (v[2] << 8) | v[3];
@@ -1609,6 +2210,148 @@ exports.valueConverter = {
             return Buffer.from(s, "hex").swap16().toString("utf16le").trim();
         },
     },
+    inchingSwitch2: {
+        to: (value, meta) => {
+            const currentState = meta.state.inching || { state: "OFF", minutes: 1, seconds: 0 };
+            const state = value.state !== undefined ? value.state : currentState.state;
+            const minutes = value.minutes !== undefined ? value.minutes : currentState.minutes;
+            const seconds = value.seconds !== undefined ? value.seconds : currentState.seconds;
+            let totalSeconds = Math.max(1, minutes * 60 + seconds);
+            if (totalSeconds > 65535)
+                totalSeconds = 65535;
+            const buf = Buffer.alloc(3);
+            buf.writeUInt8(state === "ON" ? 1 : 0, 0);
+            buf.writeUInt16BE(totalSeconds, 1);
+            return buf.toString("base64");
+        },
+        from: (value) => {
+            const buf = typeof value === "string" ? Buffer.from(value, "base64") : Buffer.from(value);
+            const state = buf.readUInt8(0) === 1 ? "ON" : "OFF";
+            const totalSeconds = buf.readUInt16BE(1);
+            const minutes = Math.floor(totalSeconds / 60);
+            const seconds = totalSeconds % 60;
+            return { state, minutes, seconds };
+        },
+    },
+    circuitBreakerFaults: {
+        from: (value) => {
+            // value is a bitmap where each bit represents a fault flag
+            const faults = [];
+            for (let i = 0; i < exports.circuitBreakerFaultList.length; i++) {
+                const bit = 1 << i;
+                if ((value & bit) === bit) {
+                    faults.push(exports.circuitBreakerFaultList[i]);
+                }
+            }
+            return faults;
+        },
+    },
+    circuitBreakerFaults1: {
+        from: (value) => {
+            // value is a bitmap where each bit represents a fault flag
+            const faults = [];
+            for (let i = 0; i < exports.circuitBreakerFaultList.length; i++) {
+                const bit = 1 << i;
+                if ((value & bit) === bit) {
+                    if (exports.circuitBreakerFaultList[i] === "magnetism")
+                        faults.push("negative_power");
+                    else
+                        faults.push(exports.circuitBreakerFaultList[i]);
+                }
+            }
+            return faults;
+        },
+    },
+    reset: {
+        to: (v) => {
+            if (v === "RESET")
+                return false;
+        },
+        from: (v) => {
+            return "idle";
+        },
+    },
+    energyBalanceAdd: {
+        to: (v) => {
+            return v * 100;
+        },
+        from: (v) => {
+            return 0;
+        },
+    },
+    circuitBreakerStatus: exports.valueConverterBasic.lookup({ off: new Enum(0), consumption: new Enum(1), production: new Enum(2) }), // only 0-1 is confirmed
+    cycleSchedule: {
+        // https://developer.tuya.com/en/docs/iot/cycle_timing?id=Kb4vhzu0ryfwm
+        // Configure device with schedules of alternating on/off cycles.
+        // Between start and end (time of day), on selected days, repeat:
+        // ON for onDuration, then OFF for offDuration.
+        from: (v) => {
+            const buf = Buffer.from(v, "base64");
+            const schedules = [];
+            for (let offset = 10; offset + 9 < buf.length; offset += 10) {
+                schedules.push({
+                    enabled: buf.readUInt8(offset) === 1,
+                    daysMask: buf.readUInt8(offset + 1),
+                    startTime: buf.readUInt16BE(offset + 2),
+                    endTime: buf.readUInt16BE(offset + 4),
+                    onDuration: buf.readUInt16BE(offset + 6),
+                    offDuration: buf.readUInt16BE(offset + 8),
+                    // unit is minutes
+                });
+            }
+            return schedules;
+        },
+    },
+    GX03ValveState: (zoneNum) => {
+        const lookup = { 0: "Manual", 1: "Auto", 2: "Closed" };
+        return {
+            from: (value, meta, options, publish) => {
+                // Set initial value to both timers to unlock UI
+                if (meta.state?.timer_1 === undefined) {
+                    publish({
+                        timer_1: 5,
+                        timer_2: 5,
+                    });
+                    const endpoint = meta.device.getEndpoint(1);
+                    void (async () => {
+                        await sendDataPointValue(endpoint, 13, 5);
+                        await sendDataPointValue(endpoint, 14, 5);
+                    })();
+                }
+                // Reset the related countdown on valve closing
+                if (value === 2) {
+                    publish({ [`countdown_${zoneNum}`]: 0 });
+                }
+                if (typeof value === "number" && value in lookup) {
+                    return lookup[value];
+                }
+                return `Unknown (${value})`;
+            },
+        };
+    },
+    autoAdjustment: {
+        to: (v) => {
+            return v === "START";
+        },
+        from: (v) => {
+            return "idle";
+        },
+    },
+    switchStates: {
+        to: (v, meta) => {
+            if (v === "SWITCH") {
+                switch (meta.state.state) {
+                    case "ON":
+                        return false;
+                    case "OFF":
+                        return true;
+                }
+            }
+        },
+        from: (v) => {
+            return "idle";
+        },
+    },
 };
 const tuyaTz = {
     power_on_behavior_1: {
@@ -1749,7 +2492,10 @@ const tuyaTz = {
         key: ["color_power_on_behavior"],
         convertSet: async (entity, key, value, meta) => {
             const v = utils.getFromLookup(value, { initial: 0, previous: 1, customized: 2 });
-            await entity.command("lightingColorCtrl", "tuyaOnStartUp", { mode: v * 256, data: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] });
+            await entity.command("lightingColorCtrl", "tuyaOnStartUp", {
+                mode: v * 256,
+                data: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            });
             return { state: { color_power_on_behavior: value } };
         },
     },
@@ -1807,7 +2553,9 @@ const tuyaTz = {
     do_not_disturb: {
         key: ["do_not_disturb"],
         convertSet: async (entity, key, value, meta) => {
-            await entity.command("lightingColorCtrl", "tuyaDoNotDisturb", { enable: value ? 1 : 0 });
+            await entity.command("lightingColorCtrl", "tuyaDoNotDisturb", {
+                enable: value ? 1 : 0,
+            });
             return { state: { do_not_disturb: value } };
         },
     },
@@ -1874,6 +2622,363 @@ const tuyaTz = {
             return { state: { inching_control_set: value } };
         },
     },
+    cover_calibration: {
+        key: [
+            "calibration",
+            "calibration_to_open",
+            "calibration_to_close",
+            "calibration_time",
+            "calibration_time_to_open",
+            "calibration_time_to_close",
+        ],
+        convertSet: async (entity, key, value, meta) => {
+            if (key.startsWith("calibration_time")) {
+                utils.assertNumber(value, key);
+                const calibration_time = value * 10;
+                if (key === "calibration_time" || key === "calibration_time_to_open") {
+                    await entity.write("closuresWindowCovering", {
+                        moesCalibrationTime: calibration_time,
+                    });
+                }
+                else if (key === "calibration_time_to_close") {
+                    await meta.device.getEndpoint(2).write("closuresWindowCovering", {
+                        moesCalibrationTime: calibration_time,
+                    });
+                }
+                return { state: { [key]: value } };
+            }
+            utils.assertString(value, key);
+            const lookup = { ON: 0, OFF: 1 };
+            value = value.toUpperCase();
+            const calibration = utils.getFromLookup(value, lookup);
+            if (key === "calibration" || key === "calibration_to_open") {
+                await entity.write("closuresWindowCovering", { tuyaCalibration: calibration });
+            }
+            else if (key === "calibration_to_close") {
+                await meta.device
+                    .getEndpoint(2)
+                    .write("closuresWindowCovering", { tuyaCalibration: calibration });
+            }
+            return { state: { [key]: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            if (key === "calibration" || key === "calibration_to_open") {
+                await entity.read("closuresWindowCovering", ["tuyaCalibration"]);
+            }
+            else if (key === "calibration_to_close") {
+                await meta.device
+                    .getEndpoint(2)
+                    .read("closuresWindowCovering", ["tuyaCalibration"]);
+            }
+            else if (key === "calibration_time" || key === "calibration_time_to_open") {
+                await entity.read("closuresWindowCovering", ["moesCalibrationTime"]);
+            }
+            else if (key === "calibration_time_to_close") {
+                await meta.device
+                    .getEndpoint(2)
+                    .read("closuresWindowCovering", ["moesCalibrationTime"]);
+            }
+        },
+    },
+    operation_mode: {
+        key: ["operation_mode"],
+        convertSet: async (entity, key, value, meta) => {
+            // modes:
+            // 0 - 'command' mode. keys send commands. useful for group control
+            // 1 - 'event' mode. keys send events. useful for handling
+            utils.assertString(value, key);
+            const endpoint = meta.device.getEndpoint(1);
+            await endpoint.write("genOnOff", { tuyaOperationMode: utils.getFromLookup(value, { command: 0, event: 1 }) });
+            return { state: { operation_mode: value.toLowerCase() } };
+        },
+        convertGet: async (entity, key, meta) => {
+            const endpoint = meta.device.getEndpoint(1);
+            await endpoint.read("genOnOff", ["tuyaOperationMode"]);
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    TS110E_onoff_brightness: {
+        key: ["state", "brightness"],
+        convertSet: async (entity, key, value, meta) => {
+            const { message, state } = meta;
+            if (message.state === "OFF" || (message.state != null && message.brightness == null)) {
+                return await tz.on_off.convertSet(entity, key, value, meta);
+            }
+            if (message.brightness != null) {
+                // set brightness
+                if (state.state === "OFF") {
+                    await entity.command("genOnOff", "on", {}, utils.getOptions(meta.mapped, entity));
+                }
+                const brightness = utils.toNumber(message.brightness, "brightness");
+                const level = utils.mapNumberRange(brightness, 0, 254, 0, 1000);
+                await entity.command("genLevelCtrl", "moveToLevelTuya", { level, transtime: 100 }, utils.getOptions(meta.mapped, entity));
+                return { state: { state: "ON", brightness } };
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            if (key === "state")
+                await tz.on_off.convertGet(entity, key, meta);
+            if (key === "brightness")
+                await entity.read("genLevelCtrl", [61440]);
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    TS110E_options: {
+        key: ["min_brightness", "max_brightness", "light_type", "switch_type"],
+        convertSet: async (entity, key, value, meta) => {
+            let payload = null;
+            if (key === "min_brightness" || key === "max_brightness") {
+                const id = key === "min_brightness" ? 64515 : 64516;
+                payload = { [id]: { value: utils.mapNumberRange(utils.toNumber(value, key), 1, 255, 0, 1000), type: 0x21 } };
+            }
+            else if (key === "light_type" || key === "switch_type") {
+                utils.assertString(value, "light_type/switch_type");
+                const lookup = key === "light_type" ? { led: 0, incandescent: 1, halogen: 2 } : { momentary: 0, toggle: 1, state: 2 };
+                payload = { 64514: { value: lookup[value], type: 0x20 } };
+            }
+            await entity.write("genLevelCtrl", payload, utils.getOptions(meta.mapped, entity));
+            return { state: { [key]: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            let id = null;
+            if (key === "min_brightness")
+                id = 64515;
+            if (key === "max_brightness")
+                id = 64516;
+            if (key === "light_type" || key === "switch_type")
+                id = 64514;
+            await entity.read("genLevelCtrl", [id]);
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    TS110E_light_onoff_brightness: {
+        ...tz.light_onoff_brightness,
+        convertSet: async (entity, key, value, meta) => {
+            const { message } = meta;
+            if (message.state === "ON" || (typeof message.brightness === "number" && message.brightness > 1)) {
+                // Does not turn off with physical press when turned on with just moveToLevelWithOnOff, required on before.
+                // https://github.com/Koenkk/zigbee2mqtt/issues/15902#issuecomment-1382848150
+                await entity.command("genOnOff", "on", {}, utils.getOptions(meta.mapped, entity));
+            }
+            return await tz.light_onoff_brightness.convertSet(entity, key, value, meta);
+        },
+    },
+    cover_reversal: {
+        key: ["motor_reversal"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertString(value, key);
+            const lookup = { ON: 1, OFF: 0 };
+            value = value.toUpperCase();
+            const reversal = utils.getFromLookup(value, lookup);
+            await entity.write("closuresWindowCovering", { tuyaMotorReversal: reversal });
+            return { state: { motor_reversal: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("closuresWindowCovering", ["tuyaMotorReversal"]);
+        },
+    },
+    moes_cover_calibration: {
+        key: ["calibration_time"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertNumber(value);
+            const calibration = value * 10;
+            await entity.write("closuresWindowCovering", { moesCalibrationTime: calibration });
+            return { state: { calibration_time: value } };
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("closuresWindowCovering", ["moesCalibrationTime"]);
+        },
+    },
+    led_control: {
+        key: ["brightness", "color", "color_temp"],
+        options: [exposes.options.color_sync()],
+        convertSet: async (entity, key, value, meta) => {
+            if (key === "brightness" &&
+                meta.state.color_mode === constants.colorModeLookup[2] &&
+                meta.message.color == null &&
+                meta.message.color_temp == null) {
+                const level = Number(value);
+                await entity.command("genLevelCtrl", "moveToLevel", { level, transtime: 0, optionsMask: 0, optionsOverride: 0 }, utils.getOptions(meta.mapped, entity));
+                globalStore.putValue(entity, "brightness", level);
+                return { state: { brightness: level } };
+            }
+            if (key === "brightness" && utils.isNumber(meta.message.color_temp)) {
+                const level = Number(value);
+                await entity.command("lightingColorCtrl", "tuyaRgbMode", { enable: 0 });
+                await entity.command("lightingColorCtrl", "moveToColorTemp", {
+                    colortemp: utils.mapNumberRange(meta.message.color_temp, 500, 154, 0, 254),
+                    transtime: 0,
+                    optionsMask: 0,
+                    optionsOverride: 0,
+                }, utils.getOptions(meta.mapped, entity));
+                await entity.command("genLevelCtrl", "moveToLevel", { level, transtime: 0, optionsMask: 0, optionsOverride: 0 }, utils.getOptions(meta.mapped, entity));
+                globalStore.putValue(entity, "brightness", level);
+                const newState = {
+                    brightness: level,
+                    color_mode: constants.colorModeLookup[2],
+                    color_temp: meta.message.color_temp,
+                };
+                return { state: libColor.syncColorState(newState, meta.state, entity, meta.options) };
+            }
+            if (key === "color_temp") {
+                utils.assertNumber(value, key);
+                const level = globalStore.getValue(entity, "brightness") || 100;
+                await entity.command("lightingColorCtrl", "tuyaRgbMode", { enable: 0 });
+                await entity.command("lightingColorCtrl", "moveToColorTemp", { colortemp: utils.mapNumberRange(value, 500, 154, 0, 254), transtime: 0, optionsMask: 0, optionsOverride: 0 }, utils.getOptions(meta.mapped, entity));
+                await entity.command("genLevelCtrl", "moveToLevel", { level, transtime: 0, optionsMask: 0, optionsOverride: 0 }, utils.getOptions(meta.mapped, entity));
+                const newState = {
+                    brightness: level,
+                    color_mode: constants.colorModeLookup[2],
+                    color_temp: value,
+                };
+                return { state: libColor.syncColorState(newState, meta.state, entity, meta.options) };
+            }
+            const zclData = {
+                brightness: globalStore.getValue(entity, "brightness") || 100,
+                // @ts-expect-error ignore
+                hue: utils.mapNumberRange(meta.state.color.h, 0, 360, 0, 254) || 100,
+                // @ts-expect-error ignore
+                saturation: utils.mapNumberRange(meta.state.color.s, 0, 100, 0, 254) || 100,
+                transtime: 0,
+            };
+            if (utils.isObject(value)) {
+                if (value.h) {
+                    zclData.hue = utils.mapNumberRange(value.h, 0, 360, 0, 254);
+                }
+                if (value.hue) {
+                    zclData.hue = utils.mapNumberRange(value.hue, 0, 360, 0, 254);
+                }
+                if (value.s) {
+                    zclData.saturation = utils.mapNumberRange(value.s, 0, 100, 0, 254);
+                }
+                if (value.saturation) {
+                    zclData.saturation = utils.mapNumberRange(value.saturation, 0, 100, 0, 254);
+                }
+                if (value.b) {
+                    zclData.brightness = Number(value.b);
+                }
+                if (value.brightness) {
+                    zclData.brightness = Number(value.brightness);
+                }
+                if (typeof value === "number") {
+                    zclData.brightness = value;
+                }
+            }
+            if (meta.message.color != null) {
+                if (utils.isObject(meta.message.color)) {
+                    if (meta.message.color.h) {
+                        zclData.hue = utils.mapNumberRange(meta.message.color.h, 0, 360, 0, 254);
+                    }
+                    if (meta.message.color.s) {
+                        zclData.saturation = utils.mapNumberRange(meta.message.color.s, 0, 100, 0, 254);
+                    }
+                    if (meta.message.color.b) {
+                        zclData.brightness = Number(meta.message.color.b);
+                    }
+                    if (meta.message.color.brightness) {
+                        zclData.brightness = Number(meta.message.color.brightness);
+                    }
+                }
+            }
+            await entity.command("lightingColorCtrl", "tuyaRgbMode", { enable: 1 });
+            await entity.command("lightingColorCtrl", "tuyaMoveToHueAndSaturationBrightness", zclData, utils.getOptions(meta.mapped, entity));
+            globalStore.putValue(entity, "brightness", zclData.brightness);
+            const newState = {
+                brightness: zclData.brightness,
+                color: {
+                    h: utils.mapNumberRange(zclData.hue, 0, 254, 0, 360),
+                    hue: utils.mapNumberRange(zclData.hue, 0, 254, 0, 360),
+                    s: utils.mapNumberRange(zclData.saturation, 0, 254, 0, 100),
+                    saturation: utils.mapNumberRange(zclData.saturation, 0, 254, 0, 100),
+                },
+                color_mode: constants.colorModeLookup[0],
+            };
+            return { state: libColor.syncColorState(newState, meta.state, entity, meta.options) };
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("lightingColorCtrl", [
+                "currentHue",
+                "currentSaturation",
+                "tuyaBrightness",
+                "tuyaRgbMode",
+                "colorTemperature",
+            ]);
+        },
+    },
+    relay_din_led_indicator: {
+        key: ["indicator_mode"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertString(value, key);
+            value = value.toLowerCase();
+            const lookup = { off: 0x00, on_off: 0x01, off_on: 0x02 };
+            const payload = utils.getFromLookup(value, lookup);
+            await entity.write("genOnOff", { 32769: { value: payload, type: 0x30 } });
+            return { state: { indicator_mode: value } };
+        },
+    },
+    led_controller: {
+        key: ["state", "color"],
+        convertSet: async (entity, key, value, meta) => {
+            if (key === "state") {
+                utils.assertString(value, key);
+                if (value.toLowerCase() === "off") {
+                    await entity.command("genOnOff", "offWithEffect", { effectid: 0x01, effectvariant: 0x01 }, utils.getOptions(meta.mapped, entity));
+                }
+                else {
+                    await entity.command("genLevelCtrl", "moveToLevelWithOnOff", { level: 255, transtime: 0, optionsMask: 0, optionsOverride: 0 }, utils.getOptions(meta.mapped, entity));
+                }
+                return { state: { state: value.toUpperCase() } };
+            }
+            if (key === "color") {
+                utils.assertObject(value);
+                const hue = utils.mapNumberRange(value.h, 0, 360, 0, 254);
+                const saturation = utils.mapNumberRange(value.s, 0, 100, 0, 254);
+                const transtime = 0;
+                const direction = 0;
+                await entity.command("lightingColorCtrl", "moveToHue", { hue, transtime, direction, optionsMask: 0, optionsOverride: 0 }, utils.getOptions(meta.mapped, entity));
+                await entity.command("lightingColorCtrl", "moveToSaturation", { saturation, transtime, optionsMask: 0, optionsOverride: 0 }, utils.getOptions(meta.mapped, entity));
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            if (key === "state") {
+                await entity.read("genOnOff", ["onOff"]);
+            }
+            else if (key === "color") {
+                await entity.read("lightingColorCtrl", ["currentHue", "currentSaturation"]);
+            }
+        },
+    },
+    ts0216_duration: {
+        key: ["duration"],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write("ssIasWd", { maxDuration: value });
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("ssIasWd", ["maxDuration"]);
+        },
+    },
+    ts0216_volume: {
+        key: ["volume"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertNumber(value);
+            if (["_TYZB01_sbpc1zrb"].includes(meta.device.manufacturerName)) {
+                const volume = value === 0 ? 0 : utils.mapNumberRange(value, 1, 100, 100, 33);
+                await entity.write("ssIasWd", { 2: { value: volume, type: 0x20 } });
+                return;
+            }
+            await entity.write("ssIasWd", { 2: { value: utils.mapNumberRange(value, 0, 100, 100, 10), type: 0x20 } });
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read("ssIasWd", [0x0002]);
+        },
+    },
+    ts0216_alarm: {
+        key: ["alarm"],
+        convertSet: async (entity, key, value, meta) => {
+            const info = value ? (2 << 4) + (1 << 2) + 0 : 0;
+            await entity.command("ssIasWd", "startWarning", { startwarninginfo: info, warningduration: 0, strobedutycycle: 0, strobelevel: 3 }, utils.getOptions(meta.mapped, entity));
+        },
+    },
 };
 exports.tz = tuyaTz;
 const tuyaFz = {
@@ -2029,7 +3134,7 @@ const tuyaFz = {
             if (utils.hasAlreadyProcessedMessage(msg, model))
                 return;
             const result = {};
-            if (!model.meta || !model.meta.tuyaDatapoints)
+            if (!model.meta?.tuyaDatapoints)
                 throw new Error("No datapoints map defined");
             const datapoints = model.meta.tuyaDatapoints;
             for (const dpValue of msg.data.dpValues) {
@@ -2134,6 +3239,218 @@ const tuyaFz = {
             return result;
         },
     },
+    cover_options: {
+        cluster: "closuresWindowCovering",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.tuyaMovingState !== undefined) {
+                const value = msg.data.tuyaMovingState;
+                const movingLookup = { 0: "UP", 1: "STOP", 2: "DOWN" };
+                result[utils.postfixWithEndpointName("moving", msg, model, meta)] = movingLookup[value];
+            }
+            if (msg.data.tuyaCalibration !== undefined) {
+                const value = msg.data.tuyaCalibration;
+                const calibrationLookup = { 0: "ON", 1: "OFF" };
+                result[utils.postfixWithEndpointName("calibration", msg, model, meta)] = calibrationLookup[value];
+            }
+            if (msg.data.tuyaMotorReversal !== undefined) {
+                const value = msg.data.tuyaMotorReversal;
+                const reversalLookup = { 0: "OFF", 1: "ON" };
+                result[utils.postfixWithEndpointName("motor_reversal", msg, model, meta)] = reversalLookup[value];
+            }
+            if (msg.data.moesCalibrationTime !== undefined) {
+                const value = msg.data.moesCalibrationTime / 10.0;
+                if (["_TZ3000_cet6ch1r", "_TZ3000_5iixzdo7"].includes(meta.device.manufacturerName)) {
+                    const endpoint = msg.endpoint.ID;
+                    const calibrationLookup = { 1: "to_open", 2: "to_close" };
+                    result[utils.postfixWithEndpointName(`calibration_time_${calibrationLookup[endpoint]}`, msg, model, meta)] = value;
+                }
+                else {
+                    result[utils.postfixWithEndpointName("calibration_time", msg, model, meta)] = value;
+                }
+            }
+            return result;
+        },
+    },
+    cover_options_2: {
+        cluster: "closuresWindowCovering",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.moesCalibrationTime !== undefined) {
+                const value = msg.data.moesCalibrationTime / 100;
+                result[utils.postfixWithEndpointName("calibration_time", msg, model, meta)] = value;
+            }
+            if (msg.data.tuyaMotorReversal !== undefined) {
+                const value = msg.data.tuyaMotorReversal;
+                const reversalLookup = { 0: "OFF", 1: "ON" };
+                result[utils.postfixWithEndpointName("motor_reversal", msg, model, meta)] = reversalLookup[value];
+            }
+            return result;
+        },
+    },
+    operation_mode: {
+        cluster: "genOnOff",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.tuyaOperationMode !== undefined) {
+                const value = msg.data.tuyaOperationMode;
+                const lookup = { 0: "command", 1: "event" };
+                return { operation_mode: lookup[value] };
+            }
+        },
+    },
+    switch_scene: {
+        cluster: "genOnOff",
+        type: "commandTuyaAction",
+        convert: (model, msg, publish, options, meta) => {
+            if (utils.hasAlreadyProcessedMessage(msg, model))
+                return;
+            // Since it is a non standard ZCL command, no default response is send from zigbee-herdsman
+            // Send the defaultResponse here, otherwise the second button click delays.
+            // https://github.com/Koenkk/zigbee2mqtt/issues/8149
+            return { action: "switch_scene", action_scene: msg.data.value };
+        },
+    },
+    multi_action: {
+        cluster: "genOnOff",
+        type: ["commandTuyaAction", "commandTuyaAction2"],
+        convert: (model, msg, publish, options, meta) => {
+            if (utils.hasAlreadyProcessedMessage(msg, model))
+                return;
+            // biome-ignore lint/suspicious/noImplicitAnyLet: ignored using `--suppress`
+            let action;
+            if (msg.type === "commandTuyaAction") {
+                const lookup = { 0: "single", 1: "double", 2: "hold" };
+                action = lookup[msg.data.value];
+            }
+            else if (msg.type === "commandTuyaAction2") {
+                const lookup = { 0: "rotate_right", 1: "rotate_left" };
+                action = lookup[msg.data.value];
+            }
+            return { action };
+        },
+    },
+    led_controller: {
+        cluster: "lightingColorCtrl",
+        type: ["attributeReport", "readResponse"],
+        options: [exposes.options.color_sync()],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.colorTemperature !== undefined) {
+                const value = Number(msg.data.colorTemperature);
+                const color_temp = utils.postfixWithEndpointName("color_temp", msg, model, meta);
+                result[color_temp] = value;
+            }
+            if (msg.data.tuyaBrightness !== undefined) {
+                const brightness = utils.postfixWithEndpointName("brightness", msg, model, meta);
+                result[brightness] = msg.data.tuyaBrightness;
+            }
+            if (msg.data.tuyaRgbMode !== undefined) {
+                const color_mode = utils.postfixWithEndpointName("color_mode", msg, model, meta);
+                if (msg.data.tuyaRgbMode === 1) {
+                    result[color_mode] = constants.colorModeLookup[0];
+                }
+                else {
+                    result[color_mode] = constants.colorModeLookup[2];
+                }
+            }
+            const color = utils.postfixWithEndpointName("color", msg, model, meta);
+            result[color] = {};
+            if (msg.data.currentHue !== undefined) {
+                result[color].hue = utils.mapNumberRange(msg.data.currentHue, 0, 254, 0, 360);
+                result[color].h = result[color].hue;
+            }
+            if (msg.data.currentSaturation !== undefined) {
+                result[color].saturation = utils.mapNumberRange(msg.data.currentSaturation, 0, 254, 0, 100);
+                result[color].s = result[color].saturation;
+            }
+            // Use postfixWithEndpointName with an empty value to get just the postfix that
+            // can be added to the result keys.
+            const epPostfix = utils.postfixWithEndpointName("", msg, model, meta);
+            return Object.assign(result, libColor.syncColorState(result, meta.state, msg.endpoint, options, epPostfix));
+        },
+    },
+    relay_din_led_indicator: {
+        cluster: "genOnOff",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const property = 0x8001;
+            if (msg.data[property] !== undefined) {
+                const dict = { 0: "off", 1: "on_off", 2: "off_on" };
+                const value = msg.data[property];
+                if (dict[value] !== undefined) {
+                    return { [utils.postfixWithEndpointName("indicator_mode", msg, model, meta)]: dict[value] };
+                }
+            }
+        },
+    },
+    TS110E: {
+        cluster: "genLevelCtrl",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data["64515"] !== undefined) {
+                result.min_brightness = utils.mapNumberRange(msg.data["64515"], 0, 1000, 1, 255);
+            }
+            if (msg.data["64516"] !== undefined) {
+                result.max_brightness = utils.mapNumberRange(msg.data["64516"], 0, 1000, 1, 255);
+            }
+            if (msg.data["61440"] !== undefined) {
+                const propertyName = utils.postfixWithEndpointName("brightness", msg, model, meta);
+                result[propertyName] = utils.mapNumberRange(msg.data["61440"], 0, 1000, 0, 255);
+            }
+            return result;
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    TS110E_light_type: {
+        cluster: "genLevelCtrl",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data["64514"] !== undefined) {
+                const lookup = { 0: "led", 1: "incandescent", 2: "halogen" };
+                result.light_type = lookup[msg.data["64514"]];
+            }
+            return result;
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    TS110E_switch_type: {
+        cluster: "genLevelCtrl",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data["64514"] !== undefined) {
+                const lookup = { 0: "momentary", 1: "toggle", 2: "state" };
+                const propertyName = utils.postfixWithEndpointName("switch_type", msg, model, meta);
+                result[propertyName] = lookup[msg.data["64514"]];
+            }
+            return result;
+        },
+    },
+    ts0216_siren: {
+        cluster: "ssIasWd",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.maxDuration !== undefined)
+                result.duration = msg.data.maxDuration;
+            if (msg.data["2"] !== undefined) {
+                result.volume = utils.mapNumberRange(msg.data["2"], 100, 10, 0, 100);
+            }
+            if (["_TYZB01_sbpc1zrb"].includes(meta.device.manufacturerName) && typeof msg.data["2"] === "number") {
+                const volData = msg.data["2"];
+                result.volume = volData === 0 ? 0 : utils.mapNumberRange(volData, 100, 33, 1, 100);
+            }
+            if (msg.data["61440"] !== undefined) {
+                result.alarm = msg.data["61440"] !== 0;
+            }
+            return result;
+        },
+    },
 };
 exports.fz = tuyaFz;
 function getHandlersForDP(name, dp, type, converter, readOnly, skip, endpoint, useGlobalSequence) {
@@ -2383,6 +3700,30 @@ const tuyaModernExtend = {
                 },
             ];
         }
+        const tuyaGenBasic = tuyaClusters.addTuyaGenBasicCluster();
+        const tuyaGenGroups = tuyaClusters.addTuyaGenGroupsCluster();
+        const tuyaGenOnOff = tuyaClusters.addTuyaGenOnOffCluster();
+        const tuyaGenLevelCtrl = tuyaClusters.addTuyaGenLevelCtrlCluster();
+        const customCluster2 = tuyaClusters.addManuSpecificTuya2Cluster();
+        const customCluster3 = tuyaClusters.addManuSpecificTuya3Cluster();
+        result.onEvent = [
+            ...(tuyaGenBasic.onEvent ?? []),
+            ...(tuyaGenGroups.onEvent ?? []),
+            ...(tuyaGenOnOff.onEvent ?? []),
+            ...(tuyaGenLevelCtrl.onEvent ?? []),
+            ...(customCluster2.onEvent ?? []),
+            ...(customCluster3.onEvent ?? []),
+            ...(result.onEvent ?? []),
+        ];
+        result.configure = [
+            ...(tuyaGenBasic.configure ?? []),
+            ...(tuyaGenGroups.configure ?? []),
+            ...(tuyaGenOnOff.configure ?? []),
+            ...(tuyaGenLevelCtrl.configure ?? []),
+            ...(customCluster2.configure ?? []),
+            ...(customCluster3.configure ?? []),
+            ...(result.configure ?? []),
+        ];
         if (dp) {
             result.fromZigbee.push(tuyaFz.datapoints);
             result.toZigbee.push(tuyaTz.datapoints);
@@ -2652,6 +3993,12 @@ const tuyaModernExtend = {
             result.toZigbee.push(tuyaTz.color_power_on_behavior);
             result.exposes.push(tuyaExposes.colorPowerOnBehavior());
         }
+        const tuyaLightingColorCtrl = tuyaClusters.addTuyaLightingColorCtrlCluster();
+        result.onEvent = [...(tuyaLightingColorCtrl.onEvent ?? []), ...(result.onEvent ?? [])];
+        result.configure = [...(tuyaLightingColorCtrl.configure ?? []), ...(result.configure ?? [])];
+        const customCluster3 = tuyaClusters.addManuSpecificTuya3Cluster();
+        result.onEvent = [...(customCluster3.onEvent ?? []), ...(result.onEvent ?? [])];
+        result.configure = [...(customCluster3.configure ?? []), ...(result.configure ?? [])];
         result.configure.push((0, utils_1.configureSetPowerSourceWhenUnknown)("Mains (single phase)"));
         return result;
     },
@@ -3015,23 +4362,184 @@ const tuyaModernExtend = {
 };
 exports.modernExtend = tuyaModernExtend;
 const tuyaClusters = {
+    addTuyaClosuresWindowCoveringCluster: () => modernExtend.deviceAddCustomCluster("closuresWindowCovering", {
+        name: "closuresWindowCovering",
+        ID: zigbee_herdsman_1.Zcl.Clusters.closuresWindowCovering.ID,
+        attributes: {
+            tuyaMovingState: { name: "tuyaMovingState", ID: 0xf000, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            tuyaCalibration: { name: "tuyaCalibration", ID: 0xf001, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            tuyaMotorReversal: { name: "tuyaMotorReversal", ID: 0xf002, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            moesCalibrationTime: { name: "moesCalibrationTime", ID: 0xf003, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    addTuyaGenBasicCluster: () => modernExtend.deviceAddCustomCluster("genBasic", {
+        name: "genBasic",
+        ID: zigbee_herdsman_1.Zcl.Clusters.genBasic.ID,
+        attributes: {},
+        commands: {
+            tuyaSetup: { name: "tuyaSetup", ID: 0xf0, parameters: [] },
+        },
+        commandsResponse: {},
+    }),
+    addTuyaGenGroupsCluster: () => modernExtend.deviceAddCustomCluster("genGroups", {
+        name: "genGroups",
+        ID: zigbee_herdsman_1.Zcl.Clusters.genGroups.ID,
+        attributes: {},
+        commands: {
+            miboxerSetZones: { name: "miboxerSetZones", ID: 0xf0, parameters: [{ name: "zones", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.LIST_MIBOXER_ZONES }] },
+        },
+        commandsResponse: {},
+    }),
+    addTuyaGenOnOffCluster: () => modernExtend.deviceAddCustomCluster("genOnOff", {
+        name: "genOnOff",
+        ID: zigbee_herdsman_1.Zcl.Clusters.genOnOff.ID,
+        attributes: {
+            tuyaBacklightSwitch: { name: "tuyaBacklightSwitch", ID: 0x5000, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            tuyaBacklightMode: { name: "tuyaBacklightMode", ID: 0x8001, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            moesStartUpOnOff: { name: "moesStartUpOnOff", ID: 0x8002, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            tuyaOperationMode: { name: "tuyaOperationMode", ID: 0x8004, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+        },
+        commands: {
+            tuyaCountdown: {
+                name: "tuyaCountdown",
+                ID: 0xf0,
+                parameters: [{ name: "data", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BUFFER }],
+            },
+            tuyaAction2: { name: "tuyaAction2", ID: 0xfc, parameters: [{ name: "value", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff }] },
+            tuyaAction: {
+                name: "tuyaAction",
+                ID: 0xfd,
+                parameters: [
+                    { name: "value", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                    { name: "data", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BUFFER },
+                ],
+            },
+        },
+        commandsResponse: {},
+    }),
+    addTuyaGenLevelCtrlCluster: () => modernExtend.deviceAddCustomCluster("genLevelCtrl", {
+        name: "genLevelCtrl",
+        ID: zigbee_herdsman_1.Zcl.Clusters.genLevelCtrl.ID,
+        attributes: {},
+        commands: {
+            moveToLevelTuya: {
+                name: "moveToLevelTuya",
+                ID: 0xf0,
+                parameters: [
+                    { name: "level", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                    { name: "transtime", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                ],
+            },
+        },
+        commandsResponse: {},
+    }),
+    addTuyaLightingColorCtrlCluster: () => modernExtend.deviceAddCustomCluster("lightingColorCtrl", {
+        name: "lightingColorCtrl",
+        ID: zigbee_herdsman_1.Zcl.Clusters.lightingColorCtrl.ID,
+        attributes: {
+            tuyaRgbMode: { name: "tuyaRgbMode", ID: 0xf000, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+            tuyaBrightness: { name: "tuyaBrightness", ID: 0xf001, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+        },
+        commands: {
+            tuyaMoveToHueAndSaturationBrightness: {
+                name: "tuyaMoveToHueAndSaturationBrightness",
+                ID: 0x06,
+                parameters: [
+                    { name: "hue", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                    { name: "saturation", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                    { name: "transtime", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                    { name: "brightness", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                ],
+            },
+            tuyaSetMinimumBrightness: {
+                name: "tuyaSetMinimumBrightness",
+                ID: 0xe0,
+                parameters: [{ name: "minimum", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff }],
+            },
+            tuyaMoveToHueAndSaturationBrightness2: {
+                name: "tuyaMoveToHueAndSaturationBrightness2",
+                ID: 0xe1,
+                parameters: [
+                    { name: "hue", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                    { name: "saturation", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                    { name: "brightness", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                ],
+            },
+            tuyaRgbMode: { name: "tuyaRgbMode", ID: 0xf0, parameters: [{ name: "enable", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff }] },
+            tuyaOnStartUp: {
+                name: "tuyaOnStartUp",
+                ID: 0xf9,
+                parameters: [
+                    { name: "mode", type: zigbee_herdsman_1.Zcl.DataType.UINT16, max: 0xffff },
+                    { name: "data", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.LIST_UINT8 },
+                ],
+            },
+            tuyaDoNotDisturb: { name: "tuyaDoNotDisturb", ID: 0xfa, parameters: [{ name: "enable", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff }] },
+            tuyaOnOffTransitionTime: {
+                name: "tuyaOnOffTransitionTime",
+                ID: 0xfb,
+                parameters: [
+                    { name: "unknown", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff },
+                    { name: "onTransitionTime", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BIG_ENDIAN_UINT24 },
+                    { name: "offTransitionTime", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BIG_ENDIAN_UINT24 },
+                ],
+            },
+        },
+        commandsResponse: {},
+    }),
+    addManuSpecificTuya2Cluster: () => modernExtend.deviceAddCustomCluster("manuSpecificTuya2", {
+        name: "manuSpecificTuya2",
+        ID: 0xe002,
+        attributes: {
+            alarmTemperatureMax: { name: "alarmTemperatureMax", ID: 0xd00a, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, min: -32768, max: 32767 },
+            alarmTemperatureMin: { name: "alarmTemperatureMin", ID: 0xd00b, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, min: -32768, max: 32767 },
+            alarmHumidityMax: { name: "alarmHumidityMax", ID: 0xd00d, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, min: -32768, max: 32767 },
+            alarmHumidityMin: { name: "alarmHumidityMin", ID: 0xd00e, type: zigbee_herdsman_1.Zcl.DataType.INT16, write: true, min: -32768, max: 32767 },
+            alarmHumidity: { name: "alarmHumidity", ID: 0xd00f, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            alarmTemperature: { name: "alarmTemperature", ID: 0xd006, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            unknown: { name: "unknown", ID: 0xd010, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
+        },
+        commands: {},
+        commandsResponse: {},
+    }),
+    addManuSpecificTuya3Cluster: () => modernExtend.deviceAddCustomCluster("manuSpecificTuya3", {
+        name: "manuSpecificTuya3",
+        ID: 0xe001,
+        attributes: {
+            powerOnBehavior: { name: "powerOnBehavior", ID: 0xd010, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            switchMode: { name: "switchMode", ID: 0xd020, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+            switchType: { name: "switchType", ID: 0xd030, type: zigbee_herdsman_1.Zcl.DataType.ENUM8, write: true, max: 0xff },
+        },
+        commands: {
+            setOptions1: { name: "setOptions1", ID: 0xe5, parameters: [{ name: "data", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BUFFER }] },
+            setOptions2: { name: "setOptions2", ID: 0xe6, parameters: [{ name: "data", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BUFFER }] },
+            setOptions3: { name: "setOptions3", ID: 0xe7, parameters: [{ name: "data", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BUFFER }] },
+        },
+        commandsResponse: {},
+    }),
     addTuyaCommonPrivateCluster: () => modernExtend.deviceAddCustomCluster("manuSpecificTuya4", {
+        name: "manuSpecificTuya4",
         ID: 0xe000,
         attributes: {
-            random_timing: { ID: 0xd001, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-            cycle_timing: { ID: 0xd002, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
-            inching: { ID: 0xd003, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+            random_timing: { name: "random_timing", ID: 0xd001, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+            cycle_timing: { name: "cycle_timing", ID: 0xd002, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
+            inching: { name: "inching", ID: 0xd003, type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR, write: true },
         },
         commands: {
             setRandomTiming: {
+                name: "setRandomTiming",
                 ID: 0xf7,
                 parameters: [{ name: "payload", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BUFFER }],
             },
             setCycleTiming: {
+                name: "setCycleTiming",
                 ID: 0xf8,
                 parameters: [{ name: "payload", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BUFFER }],
             },
             setInchingSwitch: {
+                name: "setInchingSwitch",
                 ID: 0xfb,
                 parameters: [{ name: "payload", type: zigbee_herdsman_1.Zcl.BuffaloZclDataType.BUFFER }],
             },