zigbee-herdsman-converters 22.2.0 → 23.1.0

package/dist/devices/lidl.js

@@ -0,0 +1,670 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definitions = void 0;
+const fz = __importStar(require("../converters/fromZigbee"));
+const tz = __importStar(require("../converters/toZigbee"));
+const exposes = __importStar(require("../lib/exposes"));
+const legacy = __importStar(require("../lib/legacy"));
+const m = __importStar(require("../lib/modernExtend"));
+const reporting = __importStar(require("../lib/reporting"));
+const globalStore = __importStar(require("../lib/store"));
+const tuya = __importStar(require("../lib/tuya"));
+const utils = __importStar(require("../lib/utils"));
+const e = exposes.presets;
+const ea = exposes.access;
+const fzLocal = {
+    FB20002_on: {
+        cluster: "genOnOff",
+        type: "commandTuyaAction",
+        convert: async (model, msg, publish, options, meta) => {
+            return { action: "on" };
+        },
+    },
+};
+const valueConverterLocal = {
+    wateringState: {
+        from: (value, meta, options, publish) => {
+            const result = {
+                state: value ? "ON" : "OFF",
+                ...(value
+                    ? {}
+                    : {
+                        // ensure time_left is set to zero when it's OFF
+                        time_left: 0,
+                    }),
+            };
+            // prepare the time reporting for water scheduler
+            // indications when the watering was triggered by scheduler:
+            // - scheduling is enabled
+            // - current state is on
+            // - time_left wasn't reported before and is 0
+            // - current hour & minute matches scheduling period
+            if (meta.state.schedule_mode !== "OFF" &&
+                result.state === "ON" &&
+                meta.state.time_left === 0 &&
+                !globalStore.hasValue(meta.device, "watering_timer_active_time_slot")) {
+                const now = new Date();
+                const timeslot = [1, 2, 3, 4, 5, 6]
+                    .map((slotNumber) => utils.getObjectProperty(meta.state, `schedule_slot_${slotNumber}`, {}))
+                    // @ts-expect-error ignore
+                    .find((ts) => ts.state === "ON" && ts.start_hour === now.getHours() && ts.start_minute === now.getMinutes() && ts.timer > 0);
+                if (timeslot) {
+                    // @ts-expect-error ignore
+                    const iterationDuration = timeslot.timer + timeslot.pause;
+                    // automatic watering detected
+                    globalStore.putValue(meta.device, "watering_timer_active_time_slot", {
+                        timeslot_start_timestamp: now.getTime(),
+                        // end of last watering excluding last pause
+                        // @ts-expect-error ignore
+                        timeslot_end_timestamp: now.getTime() + (timeslot.iterations * iterationDuration - timeslot.pause) * 60 * 1000,
+                        // @ts-expect-error ignore
+                        timer: timeslot.timer,
+                        iteration_inverval: null, // will be set in the next step
+                        iteration_start_timestamp: 0, // will be set in the next step
+                    });
+                }
+            }
+            // setup time reporting for water scheduler when necessary
+            if (globalStore.hasValue(meta.device, "watering_timer_active_time_slot")) {
+                const ts = globalStore.getValue(meta.device, "watering_timer_active_time_slot");
+                if (
+                // time slot execution is already completed
+                Date.now() > ts.timeslot_end_timestamp - 5000 ||
+                    // scheduling was interrupted by turning watering on manually
+                    // @ts-expect-error ignore
+                    (result.state === "ON" && result.state !== meta.state.state && meta.state.time_left > 0)) {
+                    // reporting is no longer necessary
+                    clearInterval(ts.iteration_inverval);
+                    globalStore.clearValue(meta.device, "watering_timer_active_time_slot");
+                }
+                else if (result.state === "OFF" && result.state !== meta.state.state) {
+                    // turned off --> disable reporting for this iteration only
+                    clearInterval(ts.iteration_inverval);
+                    ts.iteration_inverval = null;
+                }
+                else if (result.state === "ON" && result.state !== meta.state.state && meta.state.time_left === 0) {
+                    // automatic scheduling detected (reported as ON, but without any info about duration)
+                    ts.iteration_report = true;
+                    ts.iteration_start_timestamp = Date.now();
+                    if (ts.timer > 1) {
+                        // report every minute
+                        ts.iteration_inverval = setInterval(() => {
+                            const now = Date.now();
+                            const wateringEndTime = ts.iteration_start_timestamp + ts.timer * 60 * 1000;
+                            const timeLeftInMinutes = Math.round((wateringEndTime - now) / 1000 / 60);
+                            if (timeLeftInMinutes > 0) {
+                                if (timeLeftInMinutes === 1) {
+                                    clearInterval(ts.iteration_inverval);
+                                }
+                                publish({
+                                    time_left: timeLeftInMinutes,
+                                });
+                            }
+                        }, 60 * 1000);
+                    }
+                    // initial reporting
+                    result.time_left = ts.timer;
+                }
+            }
+            return result;
+        },
+    },
+    wateringScheduleMode: {
+        from: (value) => {
+            const [scheduleMode, scheduleValue] = value;
+            const isWeekday = scheduleMode === 0;
+            return {
+                schedule_mode: scheduleValue === 0 ? "OFF" : isWeekday ? "WEEKDAY" : "PERIODIC",
+                schedule_periodic: !isWeekday ? scheduleValue : 0,
+                schedule_weekday: ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"].reduce((scheduleMap, dayName, index) => ({
+                    ...scheduleMap,
+                    [dayName]: isWeekday && (scheduleValue & (1 << index)) > 0 ? "ON" : "OFF",
+                }), {}),
+            };
+        },
+    },
+    wateringSchedulePeriodic: {
+        to: (value) => {
+            if (!utils.isInRange(0, 7, value))
+                throw new Error(`Invalid value: ${value} (expected ${0} to ${7})`);
+            // Note: mode value of 0 switches to disabled weekday scheduler
+            const scheduleMode = value > 0 ? 1 : 0;
+            return [scheduleMode, value];
+        },
+    },
+    wateringScheduleWeekday: {
+        to: (value, meta) => {
+            // map each day to ON/OFF and use current state as default to allow partial updates
+            const dayValues = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
+                // @ts-expect-error ignore
+                .map((dayName) => utils.getObjectProperty(value, dayName, utils.getObjectProperty(meta.state.schedule_weekday, dayName, "OFF")));
+            const scheduleValue = dayValues.reduce((dayConfig, value, index) => {
+                // @ts-expect-error ignore
+                return dayConfig | (value === "ON" ? 1 << index : 0);
+            }, 0);
+            // value of 0 switches to weekday scheduler
+            const scheduleMode = 0;
+            return [scheduleMode, scheduleValue];
+        },
+    },
+    wateringScheduleSlot: (timeSlotNumber) => ({
+        from: (buffer) => {
+            return {
+                state: buffer.readUInt8(0) === 1 ? "ON" : "OFF",
+                start_hour: utils.numberWithinRange(buffer.readUInt8(1), 0, 23), // device reports non-valid value 255 initially
+                start_minute: utils.numberWithinRange(buffer.readUInt8(2), 0, 59), // device reports non-valid value 255 initially
+                timer: utils.numberWithinRange(buffer.readUInt8(3) * 60 + buffer.readUInt8(4), 1, 599), // device reports non-valid value 0 initially
+                pause: utils.numberWithinRange(buffer.readUInt8(6) * 60 + buffer.readUInt8(7), 0, 599),
+                iterations: utils.numberWithinRange(buffer.readUInt8(9), 1, 9), // device reports non-valid value 0 initially
+            };
+        },
+        to: (value, meta) => {
+            // use default values from current config to allow partial updates
+            const timeslot = utils.getObjectProperty(meta.state, `schedule_slot_${timeSlotNumber}`, {});
+            const state = utils.getObjectProperty(value, "state", timeslot.state ?? false);
+            const startHour = utils.getObjectProperty(value, "start_hour", timeslot.start_hour ?? 23);
+            const startMinute = utils.getObjectProperty(value, "start_minute", timeslot.start_minute ?? 59);
+            const duratonInMin = utils.getObjectProperty(value, "timer", timeslot.timer ?? 1);
+            const iterations = utils.getObjectProperty(value, "iterations", timeslot.iterations ?? 1);
+            const pauseInMin = utils.getObjectProperty(value, "pause", timeslot.pause ?? 0);
+            if (!utils.isInRange(0, 23, startHour))
+                throw new Error(`Invalid start hour value ${startHour} (expected ${0} to ${23})`);
+            if (!utils.isInRange(0, 59, startMinute))
+                throw new Error(`Invalid start minute value: ${startMinute} (expected ${0} to ${59})`);
+            if (!utils.isInRange(1, 599, duratonInMin))
+                throw new Error(`Invalid timer value: ${duratonInMin} (expected ${1} to ${599})`);
+            if (!utils.isInRange(1, 9, iterations))
+                throw new Error(`Invalid iterations value: ${iterations} (expected ${1} to ${9})`);
+            if (!utils.isInRange(0, 599, pauseInMin))
+                throw new Error(`Invalid pause value: ${pauseInMin} (expected ${0} to ${599})`);
+            if (iterations > 1 && pauseInMin === 0)
+                throw new Error("Pause value must be at least 1 minute when using multiple iterations");
+            return [
+                // @ts-expect-error ignore
+                state === "ON" ? 1 : 0, // time slot enabled or not
+                startHour, // start hour
+                startMinute, // start minute
+                Math.floor(duratonInMin / 60), // duration for n hours
+                duratonInMin % 60, // duration + n minutes
+                0, // what's this? -> was always reported as 0
+                Math.floor(pauseInMin / 60), // pause in hours
+                pauseInMin % 60, // pause + n minutes
+                0, // what's this? -> was always reported as 0
+                iterations, // iterations
+            ];
+        },
+    }),
+};
+exports.definitions = [
+    {
+        fingerprint: [
+            { manufacturerName: "_TZ3000_kdi2o9m6" }, // EU
+            { modelID: "TS011F", manufacturerName: "_TZ3000_plyvnuf5" }, // CH
+            { modelID: "TS011F", manufacturerName: "_TZ3000_wamqdr3f" }, // FR
+            { modelID: "TS011F", manufacturerName: "_TZ3000_00mk2xzy" }, // BS
+            { modelID: "TS011F", manufacturerName: "_TZ3000_upjrsxh1" }, // DK
+            { manufacturerName: "_TZ3000_00mk2xzy" }, // BS
+        ],
+        model: "HG06337",
+        vendor: "Lidl",
+        description: "Silvercrest smart plug (EU, CH, FR, BS, DK)",
+        extend: [tuya.modernExtend.tuyaOnOff({ indicatorMode: true })],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(11);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff"]);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint("TS011F", ["_TZ3000_j1v25l17", "_TZ3000_ynmowqk2", "_TZ3000_3uimvkn6"]),
+        model: "HG08673",
+        vendor: "Lidl",
+        description: "Silvercrest smart plug with power monitoring (EU, FR)",
+        ota: true,
+        extend: [tuya.modernExtend.tuyaOnOff({ electricalMeasurements: true, powerOutageMemory: true, indicatorMode: true, childLock: true })],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await tuya.configureMagicPacket(device, coordinatorEndpoint);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "haElectricalMeasurement"]);
+            await reporting.rmsVoltage(endpoint, { change: 5 });
+            await reporting.rmsCurrent(endpoint, { change: 50 });
+            await reporting.activePower(endpoint, { change: 10 });
+            // Energy reporting (currentSummDelivered) doesn't work; requires polling: https://github.com/Koenkk/zigbee2mqtt/issues/14356
+            endpoint.saveClusterAttributeKeyValue("haElectricalMeasurement", { acCurrentDivisor: 1000, acCurrentMultiplier: 1 });
+            endpoint.saveClusterAttributeKeyValue("seMetering", { divisor: 100, multiplier: 1 });
+            device.save();
+        },
+        options: [exposes.options.measurement_poll_interval().withDescription("Only the energy value is polled for this device.")],
+        onEvent: (type, data, device, options) => tuya.onEventMeasurementPoll(type, data, device, options, false, true),
+        whiteLabel: [tuya.whitelabel("Lidl", "HG08673-BS", "Silvercrest smart plug with power monitoring (BS)", ["_TZ3000_3uimvkn6"])],
+    },
+    {
+        fingerprint: tuya.fingerprint("TS004F", ["_TZ3000_rco1yzb1"]),
+        model: "HG08164",
+        vendor: "Lidl",
+        description: "Silvercrest smart button",
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_step, fz.command_stop, fz.battery, tuya.fz.on_off_action],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read("genBasic", [0x0004, 0x000, 0x0001, 0x0005, 0x0007, 0xfffe]);
+            await endpoint.read("genOnOff", ["tuyaOperationMode"]);
+            try {
+                await endpoint.read(0xe001, [0xd011]);
+            }
+            catch {
+                /* do nothing */
+            }
+            await endpoint.read("genPowerCfg", ["batteryVoltage", "batteryPercentageRemaining"]);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genPowerCfg"]);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff"]);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.action(["on", "off", "brightness_stop", "brightness_step_up", "brightness_step_down", "single", "double"]), e.battery()],
+    },
+    {
+        fingerprint: tuya.fingerprint("TS0211", ["_TZ1800_ladpngdx"]),
+        model: "HG06668",
+        vendor: "Lidl",
+        description: "Silvercrest smart wireless door bell button",
+        fromZigbee: [fz.battery, fz.tuya_doorbell_button, fz.ignore_basic_report],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genPowerCfg"]);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.battery(), e.action(["pressed"]), e.battery_low(), e.tamper()],
+    },
+    {
+        fingerprint: tuya.fingerprint("TY0202", ["_TZ1800_fcdjzz3s"]),
+        model: "HG06335/HG07310",
+        vendor: "Lidl",
+        description: "Silvercrest smart motion sensor",
+        extend: [
+            m.iasZoneAlarm({ zoneType: "occupancy", zoneStatusReporting: true, zoneAttributes: ["alarm_1", "tamper", "battery_low"] }),
+            m.battery(),
+        ],
+    },
+    {
+        fingerprint: tuya.fingerprint("TY0203", ["_TZ1800_ejwkn2h2", "_TZ1800_ho6i0zk9"]),
+        model: "HG06336",
+        vendor: "Lidl",
+        description: "Silvercrest smart window and door sensor",
+        extend: [m.iasZoneAlarm({ zoneType: "contact", zoneAttributes: ["alarm_1", "tamper"] }), m.battery()],
+    },
+    {
+        fingerprint: tuya.fingerprint("TS1001", ["_TYZB01_bngwdjsr"]),
+        model: "FB20-002",
+        vendor: "Lidl",
+        description: "Livarno Lux switch and dimming light remote control",
+        exposes: [
+            e.action(["on", "off", "brightness_stop", "brightness_step_up", "brightness_step_down", "brightness_move_up", "brightness_move_down"]),
+        ],
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_step, fz.command_move, fz.command_stop, fzLocal.FB20002_on],
+        toZigbee: [],
+    },
+    {
+        fingerprint: tuya.fingerprint("TS1001", ["_TYZB01_hww2py6b"]),
+        model: "FB21-001",
+        vendor: "Lidl",
+        description: "Livarno Lux switch and dimming light remote control",
+        exposes: [
+            e.action([
+                "on",
+                "off",
+                "brightness_stop",
+                "brightness_step_up",
+                "brightness_step_down",
+                "brightness_move_up",
+                "brightness_move_down",
+                "switch_scene",
+            ]),
+        ],
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_step, fz.command_move, fz.command_stop, fz.tuya_switch_scene],
+        toZigbee: [],
+    },
+    {
+        fingerprint: tuya.fingerprint("TS011F", [
+            "_TZ3000_wzauvbcs",
+            "_TZ3000_oznonj5q",
+            "_TZ3000_1obwwnmq",
+            "_TZ3000_4uf3d0ax",
+            "_TZ3000_vzopcetz",
+            "_TZ3000_vmpbygs5",
+        ]),
+        model: "HG06338",
+        vendor: "Lidl",
+        description: "Silvercrest 3 gang switch, with 4 USB (EU, FR, CZ, BS)",
+        extend: [tuya.modernExtend.tuyaOnOff({ endpoints: ["l1", "l2", "l3"] })],
+        meta: { multiEndpoint: true },
+        configure: async (device, coordinatorEndpoint) => {
+            await tuya.configureMagicPacket(device, coordinatorEndpoint);
+            for (const ID of [1, 2, 3]) {
+                await reporting.bind(device.getEndpoint(ID), coordinatorEndpoint, ["genOnOff"]);
+            }
+        },
+        endpoint: (device) => {
+            return { l1: 1, l2: 2, l3: 3 };
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint("TS0601", ["_TZE200_s8gkrkxk"]),
+        model: "HG06467",
+        vendor: "Lidl",
+        description: "Melinera smart LED string lights",
+        toZigbee: [tz.on_off, legacy.tz.silvercrest_smart_led_string],
+        fromZigbee: [fz.on_off, legacy.fz.silvercrest_smart_led_string],
+        exposes: [e.light_brightness_colorhs().setAccess("brightness", ea.STATE_SET).setAccess("color_hs", ea.STATE_SET)],
+    },
+    {
+        fingerprint: tuya.fingerprint("TS0504B", ["_TZ3210_sroezl0s"]),
+        model: "14153806L",
+        vendor: "Lidl",
+        description: "Livarno smart LED ceiling light",
+        extend: [tuya.modernExtend.tuyaLight({ colorTemp: { range: [153, 500] }, color: true })],
+        configure: async (device, coordinatorEndpoint) => {
+            device.getEndpoint(1).saveClusterAttributeKeyValue("lightingColorCtrl", { colorCapabilities: 29 });
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint("TS0601", ["_TZE200_htnnfasr"]),
+        model: "PSBZS A1",
+        vendor: "Lidl",
+        description: "Parkside smart watering timer",
+        fromZigbee: [fz.ignore_basic_report, fz.ignore_tuya_set_time, fz.ignore_onoff_report, tuya.fz.datapoints],
+        toZigbee: [tuya.tz.datapoints],
+        onEvent: async (type, data, device) => {
+            // @ts-expect-error ignore
+            await tuya.onEventSetLocalTime(type, data, device);
+            // @ts-expect-error ignore
+            if (type === "deviceInterview" && data.status === "successful") {
+                // dirty hack: reset frost guard & frost alarm to get the initial state
+                // wait 10 seconds to ensure configure is done
+                await utils.sleep(10000);
+                const endpoint = device.getEndpoint(1);
+                try {
+                    await tuya.sendDataPointBool(endpoint, 109, false);
+                    await tuya.sendDataPointBool(endpoint, 108, false);
+                }
+                catch {
+                    // ignore, just prevent any crashes
+                }
+            }
+        },
+        configure: async (device, coordinatorEndpoint) => {
+            await tuya.configureMagicPacket(device, coordinatorEndpoint);
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ["genOnOff"]);
+            // set reporting interval of genOnOff to max to "disable" it
+            // background: genOnOff reporting does not respect timer or button, that makes the on/off reporting pretty useless
+            // the device is reporting it's state change anyway via tuya DPs
+            await reporting.onOff(device.getEndpoint(1), { max: 0xffff });
+        },
+        exposes: [
+            e.battery(),
+            tuya.exposes.switch(),
+            e
+                .numeric("timer", ea.STATE_SET)
+                .withValueMin(1)
+                .withValueMax(599)
+                .withUnit("min")
+                .withDescription("Auto off after specific time for manual watering."),
+            e.numeric("time_left", ea.STATE).withUnit("min").withDescription("Remaining time until the watering turns off."),
+            e
+                .binary("frost_lock", ea.STATE, "ON", "OFF")
+                .withDescription("Indicates if the frost guard is currently active. " +
+                "If the temperature drops below 5° C, device activates frost guard and disables irrigation. " +
+                "You need to reset the frost guard to activate irrigation again. Note: There is no way to enable frost guard manually."),
+            e.enum("reset_frost_lock", ea.SET, ["RESET"]).withDescription("Resets frost lock to make the device workable again."),
+            e.enum("schedule_mode", ea.STATE, ["OFF", "WEEKDAY", "PERIODIC"]).withDescription("Scheduling mode that is currently in use."),
+            e
+                .numeric("schedule_periodic", ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(7)
+                .withUnit("day")
+                .withDescription("Watering by periodic interval: Irrigate every n days"),
+            e
+                .composite("schedule_weekday", "schedule_weekday", ea.STATE_SET)
+                .withDescription("Watering by weekday: Irrigate individually for each day.")
+                .withFeature(e.binary("monday", ea.STATE_SET, "ON", "OFF"))
+                .withFeature(e.binary("tuesday", ea.STATE_SET, "ON", "OFF"))
+                .withFeature(e.binary("wednesday", ea.STATE_SET, "ON", "OFF"))
+                .withFeature(e.binary("thursday", ea.STATE_SET, "ON", "OFF"))
+                .withFeature(e.binary("friday", ea.STATE_SET, "ON", "OFF"))
+                .withFeature(e.binary("saturday", ea.STATE_SET, "ON", "OFF"))
+                .withFeature(e.binary("sunday", ea.STATE_SET, "ON", "OFF")),
+            ...[1, 2, 3, 4, 5, 6].map((timeSlotNumber) => e
+                .composite(`schedule_slot_${timeSlotNumber}`, `schedule_slot_${timeSlotNumber}`, ea.STATE_SET)
+                .withDescription(`Watering time slot ${timeSlotNumber}`)
+                .withFeature(e.binary("state", ea.STATE_SET, "ON", "OFF").withDescription("On/off state of the time slot"))
+                .withFeature(e.numeric("start_hour", ea.STATE_SET).withUnit("h").withValueMin(0).withValueMax(23).withDescription("Starting time (hour)"))
+                .withFeature(e
+                .numeric("start_minute", ea.STATE_SET)
+                .withUnit("min")
+                .withValueMin(0)
+                .withValueMax(59)
+                .withDescription("Starting time (minute)"))
+                .withFeature(e
+                .numeric("timer", ea.STATE_SET)
+                .withUnit("min")
+                .withValueMin(1)
+                .withValueMax(599)
+                .withDescription("Auto off after specific time for scheduled watering."))
+                .withFeature(e
+                .numeric("pause", ea.STATE_SET)
+                .withUnit("min")
+                .withValueMin(0)
+                .withValueMax(599)
+                .withDescription("Pause after each iteration."))
+                .withFeature(e
+                .numeric("iterations", ea.STATE_SET)
+                .withValueMin(1)
+                .withValueMax(9)
+                .withDescription("Number of watering iterations. Works only if there is a pause."))),
+        ],
+        meta: {
+            tuyaDatapoints: [
+                [1, null, valueConverterLocal.wateringState],
+                // disable optimistic state reporting (device may not turn on when battery is low)
+                [1, "state", tuya.valueConverter.onOff, { optimistic: false }],
+                [5, "timer", tuya.valueConverter.raw],
+                [6, "time_left", tuya.valueConverter.raw],
+                [11, "battery", tuya.valueConverter.raw],
+                [108, "frost_lock", tuya.valueConverter.onOff],
+                // there is no state reporting for reset
+                [109, "reset_frost_lock", tuya.valueConverterBasic.lookup({ RESET: tuya.enum(0) }), { optimistic: false }],
+                [107, null, valueConverterLocal.wateringScheduleMode],
+                [107, "schedule_periodic", valueConverterLocal.wateringSchedulePeriodic],
+                [107, "schedule_weekday", valueConverterLocal.wateringScheduleWeekday],
+                [101, "schedule_slot_1", valueConverterLocal.wateringScheduleSlot(1)],
+                [102, "schedule_slot_2", valueConverterLocal.wateringScheduleSlot(2)],
+                [103, "schedule_slot_3", valueConverterLocal.wateringScheduleSlot(3)],
+                [104, "schedule_slot_4", valueConverterLocal.wateringScheduleSlot(4)],
+                [105, "schedule_slot_5", valueConverterLocal.wateringScheduleSlot(5)],
+                [106, "schedule_slot_6", valueConverterLocal.wateringScheduleSlot(6)],
+            ],
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint("TS0101", ["_TZ3000_br3laukf"]),
+        model: "HG06620",
+        vendor: "Lidl",
+        description: "Silvercrest garden spike with 2 sockets",
+        extend: [tuya.modernExtend.tuyaOnOff()],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff"]);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint("TS0101", ["_TZ3000_pnzfdr9y"]),
+        model: "HG06619",
+        vendor: "Lidl",
+        description: "Silvercrest outdoor plug",
+        extend: [tuya.modernExtend.tuyaOnOff()],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff"]);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint("TS0505B", ["_TZ3000_lxw3zcdk"]),
+        model: "HG08633",
+        vendor: "Lidl",
+        description: "Livarno gardenspot RGB",
+        extend: [tuya.modernExtend.tuyaLight({ colorTemp: { range: [153, 500] }, color: { modes: ["hs", "xy"] } })],
+    },
+    {
+        fingerprint: tuya.fingerprint("TS0601", ["_TZE200_chyvmhay"]),
+        model: "368308_2010",
+        vendor: "Lidl",
+        description: "Silvercrest radiator valve with thermostat",
+        fromZigbee: [fz.ignore_tuya_set_time, legacy.fromZigbee.zs_thermostat],
+        toZigbee: [
+            legacy.toZigbee.zs_thermostat_current_heating_setpoint,
+            legacy.toZigbee.zs_thermostat_child_lock,
+            legacy.toZigbee.zs_thermostat_comfort_temp,
+            legacy.toZigbee.zs_thermostat_eco_temp,
+            legacy.toZigbee.zs_thermostat_preset_mode,
+            legacy.toZigbee.zs_thermostat_system_mode,
+            legacy.toZigbee.zs_thermostat_local_temperature_calibration,
+            legacy.toZigbee.zs_thermostat_current_heating_setpoint_auto,
+            legacy.toZigbee.zs_thermostat_openwindow_time,
+            legacy.toZigbee.zs_thermostat_openwindow_temp,
+            legacy.toZigbee.zs_thermostat_binary_one,
+            legacy.toZigbee.zs_thermostat_binary_two,
+            legacy.toZigbee.zs_thermostat_away_setting,
+            legacy.toZigbee.zs_thermostat_local_schedule,
+        ],
+        onEvent: tuya.onEventSetLocalTime,
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ["genBasic"]);
+        },
+        exposes: [
+            e.child_lock(),
+            e.comfort_temperature(),
+            e.eco_temperature(),
+            e.battery_voltage(),
+            e
+                .numeric("current_heating_setpoint_auto", ea.STATE_SET)
+                .withValueMin(0.5)
+                .withValueMax(29.5)
+                .withValueStep(0.5)
+                .withUnit("°C")
+                .withDescription("Temperature setpoint automatic"),
+            e
+                .climate()
+                .withSetpoint("current_heating_setpoint", 0.5, 29.5, 0.5, ea.STATE_SET)
+                .withLocalTemperature(ea.STATE)
+                .withLocalTemperatureCalibration(-12.5, 5.5, 0.1, ea.STATE_SET)
+                .withSystemMode(["off", "heat", "auto"], ea.STATE_SET)
+                .withPreset(["schedule", "manual", "holiday", "boost"]),
+            e
+                .numeric("detectwindow_temperature", ea.STATE_SET)
+                .withUnit("°C")
+                .withDescription("Open window detection temperature")
+                .withValueMin(-10)
+                .withValueMax(35),
+            e
+                .numeric("detectwindow_timeminute", ea.STATE_SET)
+                .withUnit("min")
+                .withDescription("Open window time in minute")
+                .withValueMin(0)
+                .withValueMax(1000),
+            e.binary("binary_one", ea.STATE_SET, "ON", "OFF").withDescription("Unknown binary one"),
+            e.binary("binary_two", ea.STATE_SET, "ON", "OFF").withDescription("Unknown binary two"),
+            e.binary("away_mode", ea.STATE, "ON", "OFF").withDescription("Away mode"),
+            e
+                .composite("away_setting", "away_setting", ea.STATE_SET)
+                .withFeature(e.away_preset_days())
+                .setAccess("away_preset_days", ea.ALL)
+                .withFeature(e.away_preset_temperature())
+                .setAccess("away_preset_temperature", ea.ALL)
+                .withFeature(e.numeric("away_preset_year", ea.ALL).withUnit("year").withDescription("Start away year 20xx"))
+                .withFeature(e.numeric("away_preset_month", ea.ALL).withUnit("month").withDescription("Start away month"))
+                .withFeature(e.numeric("away_preset_day", ea.ALL).withUnit("day").withDescription("Start away day"))
+                .withFeature(e.numeric("away_preset_hour", ea.ALL).withUnit("hour").withDescription("Start away hours"))
+                .withFeature(e.numeric("away_preset_minute", ea.ALL).withUnit("min").withDescription("Start away minutes")),
+            ...["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"].map((day) => {
+                const expose = e.composite(day, day, ea.STATE_SET);
+                [1, 2, 3, 4, 5, 6, 7, 8, 9].forEach((i) => {
+                    expose.withFeature(e
+                        .numeric(`${day}_temp_${i}`, ea.ALL)
+                        .withValueMin(0.5)
+                        .withValueMax(29.5)
+                        .withValueStep(0.5)
+                        .withUnit("°C")
+                        .withDescription(`Temperature ${i}`));
+                    expose.withFeature(e
+                        .enum(`${day}_hour_${i}`, ea.STATE_SET, [
+                        "00",
+                        "01",
+                        "02",
+                        "03",
+                        "04",
+                        "05",
+                        "06",
+                        "07",
+                        "08",
+                        "09",
+                        "10",
+                        "11",
+                        "12",
+                        "13",
+                        "14",
+                        "15",
+                        "16",
+                        "17",
+                        "18",
+                        "19",
+                        "20",
+                        "21",
+                        "22",
+                        "23",
+                        "24",
+                    ])
+                        .withDescription(`Hour TO for temp ${i}`));
+                    expose.withFeature(e.enum(`${day}_minute_${i}`, ea.STATE_SET, ["00", "15", "30", "45"]).withDescription(`Minute TO for temp ${i}`));
+                });
+                return expose;
+            }),
+        ],
+    },
+];
+//# sourceMappingURL=lidl.js.map