@willieee802/zigbee-herdsman-converters 19.44.4 → 19.45.0

package/dist/devices/custom_devices_diy.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.definitions = void 0;
+exports.definitions = exports.fzLocal = exports.tzLocal = void 0;
 const zigbee_herdsman_1 = require("@willieee802/zigbee-herdsman");
 const fz = __importStar(require("../converters/fromZigbee"));
 const tz = __importStar(require("../converters/toZigbee"));
@@ -49,7 +49,7 @@ const switchTypesList = {
     switch: 0x00,
     "multi-click": 0x02,
 };
-const tzLocal = {
+exports.tzLocal = {
     tirouter: {
         key: ["transmit_power"],
         convertSet: async (entity, key, value, meta) => {
@@ -85,8 +85,138 @@ const tzLocal = {
             return;
         },
     },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    ZigUP_lock: {
+        key: ["led"],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = { off: "lockDoor", on: "unlockDoor", toggle: "toggleDoor" };
+            await entity.command("closuresDoorLock", utils.getFromLookup(value, lookup), { pincodevalue: Buffer.alloc(0) });
+        },
+    },
+    ptvo_switch_trigger: {
+        key: ["trigger", "interval"],
+        convertSet: async (entity, key, value, meta) => {
+            utils.assertNumber(value, key);
+            utils.assertEndpoint(entity);
+            if (key === "trigger") {
+                await entity.command("genOnOff", "onWithTimedOff", { ctrlbits: 0, ontime: Math.round(value / 100), offwaittime: 0 });
+            }
+            else if (key === "interval") {
+                const cluster = "genOnOff";
+                if (entity.supportsInputCluster(cluster) || entity.supportsOutputCluster(cluster)) {
+                    await entity.configureReporting(cluster, [
+                        {
+                            attribute: "onOff",
+                            minimumReportInterval: value,
+                            maximumReportInterval: value,
+                            reportableChange: 0,
+                        },
+                    ]);
+                }
+                else if (utils.hasEndpoints(meta.device, [1])) {
+                    const endpoint = meta.device.getEndpoint(1);
+                    await endpoint.configureReporting("genBasic", [
+                        {
+                            attribute: "zclVersion",
+                            minimumReportInterval: value,
+                            maximumReportInterval: value,
+                            reportableChange: 0,
+                        },
+                    ]);
+                }
+            }
+        },
+    },
+    ptvo_switch_uart: {
+        key: ["action"],
+        convertSet: async (entity, key, value, meta) => {
+            if (!value) {
+                return;
+            }
+            const payload = { 14: { value, type: 0x42 } };
+            for (const endpoint of meta.device.endpoints) {
+                const cluster = "genMultistateValue";
+                if (endpoint.supportsInputCluster(cluster) || endpoint.supportsOutputCluster(cluster)) {
+                    await endpoint.write(cluster, payload);
+                    return;
+                }
+            }
+            await entity.write("genMultistateValue", payload);
+        },
+    },
+    ptvo_switch_analog_input: {
+        key: ["l1", "l2", "l3", "l4", "l5", "l6", "l7", "l8", "l9", "l10", "l11", "l12", "l13", "l14", "l15", "l16"],
+        convertGet: async (entity, key, meta) => {
+            const epId = Number.parseInt(key.substr(1, 2), 10);
+            if (utils.hasEndpoints(meta.device, [epId])) {
+                const endpoint = meta.device.getEndpoint(epId);
+                await endpoint.read("genAnalogInput", ["presentValue", "description"]);
+            }
+        },
+        convertSet: async (entity, key, value, meta) => {
+            const epId = Number.parseInt(key.substr(1, 2), 10);
+            if (utils.hasEndpoints(meta.device, [epId])) {
+                const endpoint = meta.device.getEndpoint(epId);
+                let cluster = "genLevelCtrl";
+                if (endpoint.supportsInputCluster(cluster) || endpoint.supportsOutputCluster(cluster)) {
+                    const value2 = Number(value);
+                    if (Number.isNaN(value2)) {
+                        return;
+                    }
+                    const payload = { currentLevel: value2 };
+                    await endpoint.write(cluster, payload);
+                    return;
+                }
+                cluster = "genAnalogInput";
+                if (endpoint.supportsInputCluster(cluster) || endpoint.supportsOutputCluster(cluster)) {
+                    const value2 = Number(value);
+                    if (Number.isNaN(value2)) {
+                        return;
+                    }
+                    const payload = { presentValue: value2 };
+                    await endpoint.write(cluster, payload);
+                    return;
+                }
+            }
+            return;
+        },
+    },
+    ptvo_switch_light_brightness: {
+        key: ["brightness", "brightness_percent", "transition"],
+        options: [exposes.options.transition()],
+        convertSet: async (entity, key, value, meta) => {
+            if (key === "transition") {
+                return;
+            }
+            const cluster = "genLevelCtrl";
+            utils.assertEndpoint(entity);
+            if (entity.supportsInputCluster(cluster) || entity.supportsOutputCluster(cluster)) {
+                const message = meta.message;
+                let brightness;
+                if (message.brightness != null) {
+                    brightness = Number(message.brightness);
+                }
+                else if (message.brightness_percent != null)
+                    brightness = Math.round(Number(message.brightness_percent) * 2.55);
+                if (brightness !== undefined && brightness === 0) {
+                    message.state = "off";
+                    message.brightness = 1;
+                }
+                return await tz.light_onoff_brightness.convertSet(entity, key, value, meta);
+            }
+            throw new Error("LevelControl not supported on this endpoint.");
+        },
+        convertGet: async (entity, key, meta) => {
+            const cluster = "genLevelCtrl";
+            utils.assertEndpoint(entity);
+            if (entity.supportsInputCluster(cluster) || entity.supportsOutputCluster(cluster)) {
+                return await tz.light_onoff_brightness.convertGet(entity, key, meta);
+            }
+            throw new Error("LevelControl not supported on this endpoint.");
+        },
+    },
 };
-const fzLocal = {
+exports.fzLocal = {
     tirouter: {
         cluster: "genBasic",
         type: ["attributeReport", "readResponse"],
@@ -249,6 +379,169 @@ const fzLocal = {
             return result;
         },
     },
+    ZigUP: {
+        cluster: "genOnOff",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const lookup = {
+                "0": "timer",
+                "1": "key",
+                "2": "dig-in",
+            };
+            let ds18b20Id = null;
+            let ds18b20Value = null;
+            if (msg.data["41368"]) {
+                ds18b20Id = msg.data["41368"].split(":")[0];
+                ds18b20Value = utils.precisionRound(Number.parseFloat(msg.data["41368"].split(":")[1]), 2);
+            }
+            return {
+                state: msg.data.onOff === 1 ? "ON" : "OFF",
+                cpu_temperature: utils.precisionRound(msg.data["41361"], 2),
+                external_temperature: utils.precisionRound(msg.data["41362"], 1),
+                external_humidity: utils.precisionRound(msg.data["41363"], 1),
+                s0_counts: msg.data["41364"],
+                adc_volt: utils.precisionRound(msg.data["41365"], 3),
+                dig_input: msg.data["41366"],
+                reason: lookup[msg.data["41367"]],
+                [`${ds18b20Id}`]: ds18b20Value,
+            };
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    CC2530ROUTER_led: {
+        cluster: "genOnOff",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            return { led: msg.data.onOff === 1 };
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    CC2530ROUTER_meta: {
+        cluster: "genBinaryValue",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const data = msg.data;
+            return {
+                description: data.description,
+                type: data.inactiveText,
+                rssi: data.presentValue,
+            };
+        },
+    },
+    // biome-ignore lint/style/useNamingConvention: ignored using `--suppress`
+    DNCKAT_S00X_buttons: {
+        cluster: "genOnOff",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const action = msg.data.onOff === 1 ? "release" : "hold";
+            return { action: (0, utils_1.postfixWithEndpointName)(action, msg, model, meta) };
+        },
+    },
+    ptvo_switch_uart: {
+        cluster: "genMultistateValue",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            let data = msg.data.stateText; // ZclArray is only for write
+            if (Array.isArray(data)) {
+                let bHex = false;
+                let code;
+                let index;
+                for (index = 0; index < data.length; index += 1) {
+                    code = data[index];
+                    if (code < 32 || code > 127) {
+                        bHex = true;
+                        break;
+                    }
+                }
+                if (!bHex) {
+                    data = data.toString();
+                }
+                else {
+                    data = [...data];
+                }
+            }
+            return { action: data };
+        },
+    },
+    ptvo_switch_analog_input: {
+        cluster: "genAnalogInput",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const payload = {};
+            const channel = msg.endpoint.ID;
+            const name = `l${channel}`;
+            const endpoint = msg.endpoint;
+            payload[name] = utils.precisionRound(msg.data.presentValue, 3);
+            const cluster = "genLevelCtrl";
+            if (endpoint && (endpoint.supportsInputCluster(cluster) || endpoint.supportsOutputCluster(cluster))) {
+                payload[`brightness_${name}`] = msg.data.presentValue;
+            }
+            else if (msg.data.description !== undefined) {
+                const data1 = msg.data.description;
+                if (data1) {
+                    const data2 = data1.split(",");
+                    const devid = data2[1];
+                    const unit = data2[0];
+                    if (devid) {
+                        payload[`device_${name}`] = devid;
+                    }
+                    const valRaw = msg.data.presentValue;
+                    if (unit) {
+                        let val = utils.precisionRound(valRaw, 1);
+                        const nameLookup = {
+                            C: "temperature",
+                            "%": "humidity",
+                            m: "altitude",
+                            Pa: "pressure",
+                            ppm: "quality",
+                            psize: "particle_size",
+                            V: "voltage",
+                            A: "current",
+                            Wh: "energy",
+                            W: "power",
+                            Hz: "frequency",
+                            pf: "power_factor",
+                            lx: "illuminance",
+                        };
+                        let nameAlt = "";
+                        if (unit === "A" || unit === "pf") {
+                            if (valRaw < 1) {
+                                val = utils.precisionRound(valRaw, 3);
+                            }
+                        }
+                        if (unit.startsWith("mcpm") || unit.startsWith("ncpm")) {
+                            const num = unit.substr(4, 1);
+                            nameAlt = num === "A" ? `${unit.substr(0, 4)}10` : unit;
+                            val = utils.precisionRound(valRaw, 2);
+                        }
+                        else {
+                            nameAlt = nameLookup[unit];
+                        }
+                        if (nameAlt === undefined) {
+                            const valueIndex = Number.parseInt(unit, 10);
+                            if (!Number.isNaN(valueIndex)) {
+                                nameAlt = `val${unit}`;
+                            }
+                        }
+                        if (nameAlt !== undefined) {
+                            payload[`${nameAlt}_${name}`] = val;
+                        }
+                    }
+                }
+            }
+            return payload;
+        },
+    },
+    ptvo_multistate_action: {
+        cluster: "genMultistateInput",
+        type: ["attributeReport", "readResponse"],
+        convert: (model, msg, publish, options, meta) => {
+            const actionLookup = { 0: "release", 1: "single", 2: "double", 3: "tripple", 4: "hold" };
+            const value = msg.data.presentValue;
+            const action = actionLookup[value];
+            return { action: (0, utils_1.postfixWithEndpointName)(action, msg, model, meta) };
+        },
+    },
 };
 function ptvoGetMetaOption(device, key, defaultValue) {
     if (!utils.isDummyDevice(device) && device.meta) {
@@ -339,11 +632,13 @@ exports.definitions = [
             { modelID: "ZB-GW04", manufacturerName: "easyiot", applicationVersion: 200 },
             { modelID: "ZB-GW04-1v1", manufacturerName: "easyiot", applicationVersion: 200 },
             { modelID: "ZB-GW04-1v2", manufacturerName: "easyiot", applicationVersion: 200 },
+            { modelID: "ZBM-MG24", manufacturerName: "Inswift", applicationVersion: 200 },
             { modelID: "SkyConnect", manufacturerName: "NabuCasa", applicationVersion: 200 },
             { modelID: "ZBT-2", manufacturerName: "NabuCasa", applicationVersion: 200 },
             { modelID: "SLZB-06M", manufacturerName: "SMLIGHT", applicationVersion: 200 },
             { modelID: "SLZB-06MG24", manufacturerName: "SMLIGHT", applicationVersion: 200 },
             { modelID: "SLZB-06MG26", manufacturerName: "SMLIGHT", applicationVersion: 200 },
+            { modelID: "SLZB-06MG26U", manufacturerName: "SMLIGHT", applicationVersion: 200 },
             { modelID: "SLZB-07", manufacturerName: "SMLIGHT", applicationVersion: 200 },
             { modelID: "SLZB-07MG24", manufacturerName: "SMLIGHT", applicationVersion: 200 },
             { modelID: "DONGLE-E", manufacturerName: "SONOFF", applicationVersion: 200 },
@@ -353,8 +648,6 @@ exports.definitions = [
             { modelID: "MGM240P", manufacturerName: "SparkFun", applicationVersion: 200 },
             { modelID: "MGM24", manufacturerName: "TubesZB", applicationVersion: 200 },
             { modelID: "BM24", manufacturerName: "TubesZB", applicationVersion: 200 },
-            { modelID: "EFR32MG21-V1", manufacturerName: "ZBGW7688", applicationVersion: 200 },
-            { modelID: "EFR32MG21-V2", manufacturerName: "ZBGW7688", applicationVersion: 200 },
         ],
         model: "Silabs series 2 router",
         vendor: "Silabs",
@@ -375,8 +668,8 @@ exports.definitions = [
         model: "ti.router",
         vendor: "Custom devices (DiY)",
         description: "Texas Instruments router",
-        fromZigbee: [fzLocal.tirouter],
-        toZigbee: [tzLocal.tirouter],
+        fromZigbee: [exports.fzLocal.tirouter],
+        toZigbee: [exports.tzLocal.tirouter],
         exposes: [
             e
                 .numeric("transmit_power", ea.ALL)
@@ -399,8 +692,8 @@ exports.definitions = [
         model: "CC2530.ROUTER",
         vendor: "Custom devices (DiY)",
         description: "CC2530 router",
-        fromZigbee: [fz.CC2530ROUTER_led, fz.CC2530ROUTER_meta],
-        toZigbee: [tz.ptvo_switch_trigger],
+        fromZigbee: [exports.fzLocal.CC2530ROUTER_led, exports.fzLocal.CC2530ROUTER_meta],
+        toZigbee: [exports.tzLocal.ptvo_switch_trigger],
         exposes: [e.binary("led", ea.STATE, true, false)],
     },
     {
@@ -429,25 +722,25 @@ exports.definitions = [
         fromZigbee: [
             fz.battery,
             fz.on_off,
-            fz.ptvo_multistate_action,
-            fz.ptvo_switch_uart,
-            fz.ptvo_switch_analog_input,
+            exports.fzLocal.ptvo_multistate_action,
+            exports.fzLocal.ptvo_switch_uart,
+            exports.fzLocal.ptvo_switch_analog_input,
             fz.brightness,
             fz.temperature,
-            fzLocal.humidity2,
-            fzLocal.pressure2,
-            fzLocal.illuminance2,
+            exports.fzLocal.humidity2,
+            exports.fzLocal.pressure2,
+            exports.fzLocal.illuminance2,
             fz.electrical_measurement,
             fz.metering,
             fz.co2,
             fz.color_colortemp,
         ],
         toZigbee: [
-            tz.ptvo_switch_trigger,
-            tz.ptvo_switch_uart,
-            tz.ptvo_switch_analog_input,
-            tz.ptvo_switch_light_brightness,
-            tzLocal.ptvo_on_off,
+            exports.tzLocal.ptvo_switch_trigger,
+            exports.tzLocal.ptvo_switch_uart,
+            exports.tzLocal.ptvo_switch_analog_input,
+            exports.tzLocal.ptvo_switch_light_brightness,
+            exports.tzLocal.ptvo_on_off,
             tz.light_color,
         ],
         exposes: (device, options) => {
@@ -739,7 +1032,7 @@ exports.definitions = [
         model: "DNCKATSW002",
         vendor: "Custom devices (DiY)",
         description: "DNCKAT double key wired wall light switch",
-        fromZigbee: [fz.DNCKAT_S00X_buttons],
+        fromZigbee: [exports.fzLocal.DNCKAT_S00X_buttons],
         extend: [m.deviceEndpoints({ endpoints: { left: 1, right: 2 } }), m.onOff({ endpointNames: ["left", "right"] })],
         exposes: [e.action(["release_left", "hold_left", "release_right", "hold_right"])],
     },
@@ -748,7 +1041,7 @@ exports.definitions = [
         model: "DNCKATSW003",
         vendor: "Custom devices (DiY)",
         description: "DNCKAT triple key wired wall light switch",
-        fromZigbee: [fz.DNCKAT_S00X_buttons],
+        fromZigbee: [exports.fzLocal.DNCKAT_S00X_buttons],
         extend: [m.deviceEndpoints({ endpoints: { left: 1, center: 2, right: 3 } }), m.onOff({ endpointNames: ["left", "center", "right"] })],
         exposes: [e.action(["release_left", "hold_left", "release_right", "hold_right", "release_center", "hold_center"])],
     },
@@ -757,7 +1050,7 @@ exports.definitions = [
         model: "DNCKATSW004",
         vendor: "Custom devices (DiY)",
         description: "DNCKAT quadruple key wired wall light switch",
-        fromZigbee: [fz.DNCKAT_S00X_buttons],
+        fromZigbee: [exports.fzLocal.DNCKAT_S00X_buttons],
         extend: [
             m.deviceEndpoints({ endpoints: { bottom_left: 1, bottom_right: 2, top_left: 3, top_right: 4 } }),
             m.onOff({ endpointNames: ["bottom_left", "bottom_right", "top_left", "top_right"] }),
@@ -780,8 +1073,8 @@ exports.definitions = [
         model: "ZigUP",
         vendor: "Custom devices (DiY)",
         description: "CC2530 based Zigbee relais, switch, sensor and router",
-        fromZigbee: [fz.ZigUP],
-        toZigbee: [tz.on_off, tz.light_color, tz.ZigUP_lock],
+        fromZigbee: [exports.fzLocal.ZigUP],
+        toZigbee: [tz.on_off, tz.light_color, exports.tzLocal.ZigUP_lock],
         exposes: [e.switch()],
     },
     {
@@ -852,8 +1145,8 @@ exports.definitions = [
         model: "MULTI-ZIG-SW",
         vendor: "smarthjemmet.dk",
         description: "Multi switch from Smarthjemmet.dk",
-        fromZigbee: [fzLocal.multi_zig_sw_switch_buttons, fzLocal.multi_zig_sw_battery, fzLocal.multi_zig_sw_switch_config],
-        toZigbee: [tzLocal.multi_zig_sw_switch_type],
+        fromZigbee: [exports.fzLocal.multi_zig_sw_switch_buttons, exports.fzLocal.multi_zig_sw_battery, exports.fzLocal.multi_zig_sw_switch_config],
+        toZigbee: [exports.tzLocal.multi_zig_sw_switch_type],
         exposes: [
             ...[e.enum("switch_type_1", exposes.access.ALL, Object.keys(switchTypesList)).withEndpoint("button_1")],
             ...[e.enum("switch_type_2", exposes.access.ALL, Object.keys(switchTypesList)).withEndpoint("button_2")],
@@ -1092,8 +1385,8 @@ exports.definitions = [
         model: "QUAD-ZIG-SW",
         vendor: "smarthjemmet.dk",
         description: "FUGA compatible switch from Smarthjemmet.dk",
-        fromZigbee: [fzLocal.multi_zig_sw_switch_buttons, fzLocal.multi_zig_sw_battery, fzLocal.multi_zig_sw_switch_config],
-        toZigbee: [tzLocal.multi_zig_sw_switch_type],
+        fromZigbee: [exports.fzLocal.multi_zig_sw_switch_buttons, exports.fzLocal.multi_zig_sw_battery, exports.fzLocal.multi_zig_sw_switch_config],
+        toZigbee: [exports.tzLocal.multi_zig_sw_switch_type],
         exposes: [
             ...[e.enum("switch_type_1", exposes.access.ALL, Object.keys(switchTypesList)).withEndpoint("button_1")],
             ...[e.enum("switch_type_2", exposes.access.ALL, Object.keys(switchTypesList)).withEndpoint("button_2")],
@@ -1117,8 +1410,8 @@ exports.definitions = [
         model: "ptvo_counter_2ch",
         vendor: "Custom devices (DiY)",
         description: "2 channel counter",
-        fromZigbee: [fz.battery, fz.ptvo_switch_analog_input, fz.on_off],
-        toZigbee: [tz.ptvo_switch_trigger, tz.ptvo_switch_analog_input, tz.on_off],
+        fromZigbee: [fz.battery, exports.fzLocal.ptvo_switch_analog_input, fz.on_off],
+        toZigbee: [exports.tzLocal.ptvo_switch_trigger, exports.tzLocal.ptvo_switch_analog_input, tz.on_off],
         exposes: [
             e.battery(),
             e
@@ -1187,7 +1480,7 @@ exports.definitions = [
         vendor: "Custom devices (DiY)",
         description: "ACW02 HVAC Thermostat Controller via Zigbee (Router)",
         meta: { multiEndpoint: true },
-        fromZigbee: [fzLocal.acw02_thermostat, fzLocal.acw02_clean_status, fzLocal.acw02_error_status, fz.on_off, fzLocal.acw02_error_text],
+        fromZigbee: [exports.fzLocal.acw02_thermostat, exports.fzLocal.acw02_clean_status, exports.fzLocal.acw02_error_status, fz.on_off, exports.fzLocal.acw02_error_text],
         toZigbee: [tz.thermostat_local_temperature, tz.thermostat_occupied_heating_setpoint, tz.thermostat_system_mode, tz.on_off],
         exposes: [
             e
@@ -1296,7 +1589,71 @@ exports.definitions = [
         vendor: "Custom devices (DiY)",
         description: "Zigbee Gas counter",
         ota: true,
-        extend: [m.gasMeter({ cluster: "metering", power: false }), m.battery({ voltage: true, lowStatus: true })],
+        extend: [
+            m.gasMeter({ cluster: "metering", power: false }),
+            m.battery({ voltage: true, lowStatus: true }),
+            m.deviceAddCustomCluster("seMetering", {
+                ID: 0x0702,
+                attributes: {
+                    setSummationDelivered: {
+                        ID: 0xf000,
+                        name: "setCurrentSummationDelivered",
+                        type: zigbee_herdsman_1.Zcl.DataType.UINT48,
+                        manufacturerCode: 0x8888,
+                        write: true,
+                    },
+                },
+                commands: {},
+                commandsResponse: {},
+                name: "seMetering",
+            }),
+            m.numeric({
+                name: "gas_counter_set",
+                cluster: "seMetering",
+                attribute: "setSummationDelivered",
+                description: "Write absolute gas meter value",
+                access: "SET",
+                valueMin: 0,
+                valueMax: 281474976710655,
+            }),
+        ],
+        meta: {
+            publishDuplicateTransaction: true,
+        },
+    },
+    {
+        zigbeeModel: ["ZG-204ZL-z"],
+        model: "ZG-204ZL-z",
+        vendor: "Custom devices (DiY)",
+        description: "Luminance motion sensor (pvvx/ZigbeeTLc)",
+        ota: true,
+        extend: [
+            m.battery(),
+            m.occupancy(),
+            m.illuminance(),
+            m.enumLookup({
+                name: "power_on_behavior",
+                cluster: "genOnOff",
+                attribute: "startUpOnOff",
+                lookup: {
+                    off: 0,
+                    on: 1,
+                    toggle: 2,
+                    previous: 255,
+                },
+                description: "Power-on behavior",
+            }),
+            m.numeric({
+                name: "pir_timeout",
+                cluster: "msOccupancySensing",
+                attribute: "pirOToUDelay",
+                unit: "s",
+                valueMin: 0,
+                valueMax: 65535,
+                access: "ALL",
+                description: "PIR timeout in seconds",
+            }),
+        ],
     },
 ];
 //# sourceMappingURL=custom_devices_diy.js.map