zigbee-herdsman-converters 14.0.387 → 14.0.391

package/converters/fromZigbee.js

@@ -1860,6 +1860,36 @@ const converters = {
             }
         },
     },
+    tuya_illuminance_sensor: {
+        cluster: `manuSpecificTuya`,
+        type: [`commandDataReport`, `commandDataResponse`],
+        options: [exposes.options.precision('illuminance_lux'),
+            exposes.options.calibration('illuminance_lux', 'percentual')],
+        convert: (() => {
+            const brightnessState = {
+                0: 'low',
+                1: 'middle',
+                2: 'high',
+                3: 'strong',
+            };
+            return (model, msg, publish, options, meta) => {
+                const dpValue = tuya.firstDpValue(msg, meta, `tuya_illuminance_sensor`);
+                const dp = dpValue.dp;
+                const value = tuya.getDataValue(dpValue);
+                switch (dp) {
+                case tuya.dataPoints.state:
+                    return {brightness_state: brightnessState[value]};
+                case tuya.dataPoints.tIlluminanceLux:
+                    return {illuminance_lux: calibrateAndPrecisionRoundOptions(value, options, 'illuminance_lux')};
+                default:
+                    meta.logger.warn(
+                        `zigbee-herdsman-converters:tuya_illuminance_sensor: NOT RECOGNIZED ` +
+                      `DP #${dp} with data ${JSON.stringify(dpValue)}`,
+                    );
+                }
+            };
+        })(),
+    },
     ts0201_temperature_humidity_alarm: {
         cluster: 'manuSpecificTuya_2',
         type: ['attributeReport', 'readResponse'],
@@ -4362,6 +4392,14 @@ const converters = {
         convert: (model, msg, publis, options, meta) => {
             // Don't use in production!
             // Used in: https://www.zigbee2mqtt.io/how_tos/how_to_support_new_tuya_devices.html
+            const getType = (datatype) => {
+                const entry = Object.entries(tuya.dataTypes).find(([typeName, typeId]) => typeId === datatype);
+                return (entry ? entry[0] : 'unknown');
+            };
+            const getAllDpIds = (dp) => {
+                const entries = Object.entries(tuya.dataPoints).filter(([dpName, dpId]) => dpId === dp);
+                return entries.map(([dpName, dpId]) => dpName);
+            };
             const getHex = (value) => {
                 let hex = value.toString(16);
                 if (hex.length < 2) {
@@ -4372,6 +4410,11 @@ const converters = {
             const now = Date.now().toString();
             let dataStr = '';
             for (const [i, dpValue] of msg.data.dpValues.entries()) {
+                const value = tuya.getDataValue(dpValue);
+                meta.logger.info(`zigbee-herdsman-converters:tuya_data_point_dump: Received DP #${
+                    dpValue.dp} from ${meta.device.ieeeAddr} with raw data '${JSON.stringify(dpValue)}': type='${msg.type}', datatype='${
+                    getType(dpValue.datatype)}', value='${value}', known DP# usage: ${JSON.stringify(getAllDpIds(dpValue.dp))}`);
+
                 dataStr +=
                     now + ' ' +
                     meta.device.ieeeAddr + ' ' +
@@ -7614,6 +7657,57 @@ const converters = {
             return result;
         },
     },
+    tuya_radar_sensor_fall: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'tuya_radar_sensor_fall');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+            let result = null;
+            switch (dp) {
+            case tuya.dataPoints.trsfPresenceState:
+                result = {presence: {0: false, 1: true}[value]};
+                break;
+            case tuya.dataPoints.trsfMotionState:
+                result = {occupancy: {1: false, 2: true}[value]};
+                break;
+            case tuya.dataPoints.trsfMotionSpeed:
+                result = {motion_speed: value};
+                break;
+            case tuya.dataPoints.trsfMotionDirection:
+                result = {motion_direction: tuya.tuyaRadar.motionDirection[value]};
+                break;
+            case tuya.dataPoints.trsfScene:
+                result = {radar_scene: tuya.tuyaRadar.radarScene[value]};
+                break;
+            case tuya.dataPoints.trsfSensitivity:
+                result = {radar_sensitivity: value};
+                break;
+            case tuya.dataPoints.trsfIlluminanceLux:
+                result = {illuminance_lux: value};
+                break;
+            case tuya.dataPoints.trsfTumbleAlarmTime:
+                result = {tumble_alarm_time: value+1};
+                break;
+            case tuya.dataPoints.trsfTumbleSwitch:
+                result = {tumble_switch: {false: 'OFF', true: 'ON'}[value]};
+                break;
+            case tuya.dataPoints.trsfFallDownStatus:
+                result = {fall_down_status: {0: false, 1: true}[value]};
+                break;
+            case tuya.dataPoints.trsfStaticDwellAlarm:
+                result = {static_dwell_alarm: value};
+                break;
+            case tuya.dataPoints.trsfFallSensitivity:
+                result = {fall_sensitivity: value};
+                break;
+            default:
+                meta.logger.warn(`fromZigbee.tuya_radar_sensor_fall: NOT RECOGNIZED DP ${dp} with data ${JSON.stringify(dpValue)}`);
+            }
+            return result;
+        },
+    },
     tuya_smart_vibration_sensor: {
         cluster: 'manuSpecificTuya',
         type: ['commandGetData', 'commandDataResponse', 'raw'],

package/converters/toZigbee.js

@@ -1270,7 +1270,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             let result;
             if (meta.options.thermostat_unit === 'fahrenheit') {
-                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
             } else {
                 result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
             }
@@ -1287,7 +1287,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             let result;
             if (meta.options.thermostat_unit === 'fahrenheit') {
-                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
             } else {
                 result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
             }
@@ -1304,7 +1304,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             let result;
             if (meta.options.thermostat_unit === 'fahrenheit') {
-                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
             } else {
                 result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
             }
@@ -1321,7 +1321,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             let result;
             if (meta.options.thermostat_unit === 'fahrenheit') {
-                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
             } else {
                 result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
             }
@@ -1356,7 +1356,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             let result;
             if (meta.options.thermostat_unit === 'fahrenheit') {
-                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
             } else {
                 result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
             }
@@ -1372,7 +1372,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             let result;
             if (meta.options.thermostat_unit === 'fahrenheit') {
-                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
             } else {
                 result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
             }
@@ -1982,7 +1982,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             const lookup = {'siren_led': 3, 'siren': 2, 'led': 1, 'nothing': 0};
             await entity.write('genBasic', {0x400a: {value: lookup[value], type: 32}},
-                {manufacturerCode: 0x1168, disableDefaultResponse: true, sendWhenActive: true});
+                {manufacturerCode: 0x1168, disableDefaultResponse: true, sendWhen: 'active'});
             return {state: {alert_behaviour: value}};
         },
     },
@@ -6099,7 +6099,7 @@ const converters = {
         key: ['keypad_lockout'],
         convertSet: async (entity, key, value, meta) => {
             const keypadLockout = utils.getKey(constants.keypadLockoutMode, value, value, Number);
-            entity.write('hvacUserInterfaceCfg', {keypadLockout}, {sendWhenActive: true});
+            entity.write('hvacUserInterfaceCfg', {keypadLockout}, {sendWhen: 'active'});
             entity.saveClusterAttributeKeyValue('hvacUserInterfaceCfg', {keypadLockout});
             return {state: {keypad_lockout: value}};
         },
@@ -6238,7 +6238,7 @@ const converters = {
         key: ['calibrate_valve'],
         convertSet: async (entity, key, value, meta) => {
             await entity.command('hvacThermostat', 'wiserSmartCalibrateValve', {},
-                {srcEndpoint: 11, disableDefaultResponse: true, sendWhenActive: true});
+                {srcEndpoint: 11, disableDefaultResponse: true, sendWhen: 'active'});
             return {state: {'calibrate_valve': value}};
         },
     },
@@ -6260,7 +6260,7 @@ const converters = {
         key: ['local_temperature_calibration'],
         convertSet: (entity, key, value, meta) => {
             entity.write('hvacThermostat', {localTemperatureCalibration: Math.round(value * 10)},
-                {srcEndpoint: 11, disableDefaultResponse: true, sendWhenActive: true});
+                {srcEndpoint: 11, disableDefaultResponse: true, sendWhen: 'active'});
             return {state: {local_temperature_calibration: value}};
         },
     },
@@ -6269,7 +6269,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             const keypadLockout = utils.getKey(constants.keypadLockoutMode, value, value, Number);
             await entity.write('hvacUserInterfaceCfg', {keypadLockout},
-                {srcEndpoint: 11, disableDefaultResponse: true, sendWhenActive: true});
+                {srcEndpoint: 11, disableDefaultResponse: true, sendWhen: 'active'});
             return {state: {keypad_lockout: value}};
         },
     },
@@ -6371,6 +6371,30 @@ const converters = {
             }
         },
     },
+    tuya_radar_sensor_fall: {
+        key: ['radar_scene', 'radar_sensitivity', 'tumble_alarm_time', 'tumble_switch', 'fall_sensitivity'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'radar_scene':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.trsfScene, utils.getKey(tuya.tuyaRadar.radarScene, value));
+                break;
+            case 'radar_sensitivity':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.trsfSensitivity, value);
+                break;
+            case 'tumble_switch':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.trsfTumbleSwitch, {'on': true, 'off': false}[value.toLowerCase()]);
+                break;
+            case 'tumble_alarm_time':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.trsfTumbleAlarmTime, value-1);
+                break;
+            case 'fall_sensitivity':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.trsfFallSensitivity, value);
+                break;
+            default: // Unknown Key
+                meta.logger.warn(`toZigbee.tuya_radar_sensor_fall: Unhandled Key ${key}`);
+            }
+        },
+    },
     javis_microwave_sensor: {
         key: [
             'illuminance_calibration', 'led_enable',

package/devices/enbrighten.js

@@ -100,4 +100,17 @@ module.exports = [
             await reporting.onOff(endpoint);
         },
     },
+    {
+        zigbeeModel: ['43096'],
+        model: '43096',
+        vendor: 'Enbrighten',
+        description: 'Zigbee plug-in smart dimmer with dual controlled outlets',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint);
+        },
+    },
 ];

package/devices/ikea.js

@@ -64,6 +64,12 @@ const tradfriExtend = {
         ota: ota.tradfri,
         onEvent: bulbOnEvent,
     }),
+    light_onoff_brightness_color: (options = {}) => ({
+        ...extend.light_onoff_brightness_color(options),
+        exposes: extend.light_onoff_brightness_color(options).exposes.concat(e.power_on_behavior()),
+        ota: ota.tradfri,
+        onEvent: bulbOnEvent,
+    }),
 };
 
 const manufacturerOptions = {manufacturerCode: herdsman.Zcl.ManufacturerCode.IKEA_OF_SWEDEN};
@@ -369,7 +375,7 @@ module.exports = [
         model: 'LED1624G9',
         vendor: 'IKEA',
         description: 'TRADFRI LED bulb E14/E26/E27 600 lumen, dimmable, color, opal white',
-        extend: tradfriExtend.light_onoff_brightness_colortemp_color({colorTempRange: [250, 454]}),
+        extend: tradfriExtend.light_onoff_brightness_color(),
         meta: {supportsHueAndSaturation: false},
     },
     {

package/devices/lidl.js

@@ -485,6 +485,17 @@ module.exports = [
             device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
         },
     },
+    {
+        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3210_r0xgkft5'}],
+        model: '14156506L',
+        vendor: 'Lidl',
+        description: 'Livarno Lux smart LED mood light',
+        ...extend.light_onoff_brightness_colortemp_color({disableColorTempStartup: true, colorTempRange: [153, 500]}),
+        meta: {applyRedFix: true, enhancedHue: false},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
+        },
+    },
     {
         fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3000_quqaeew6'}],
         model: 'HG07834A',

package/devices/philips.js

@@ -1194,12 +1194,12 @@ module.exports = [
         ota: ota.zigbeeOTA,
     },
     {
-        zigbeeModel: ['3261031P6'],
+        zigbeeModel: ['3261031P6', '929003055001'],
         model: '3261031P6',
         vendor: 'Philips',
         description: 'Hue Being white',
         meta: {turnsOffAtBrightness1: true},
-        extend: hueExtend.light_onoff_brightness_colortemp(),
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
         ota: ota.zigbeeOTA,
     },
     {
@@ -2619,4 +2619,12 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['915005997501'],
+        model: '915005997501',
+        vendor: 'Philips',
+        description: 'Hue Bluetooth white & color ambiance ceiling lamp Infuse large',
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        ota: ota.zigbeeOTA,
+    },
 ];

package/devices/tuya.js

@@ -926,6 +926,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_hue3yfsn'}, /* model: 'TV02-Zigbee', vendor: 'TuYa' */
             {modelID: 'TS0601', manufacturerName: '_TZE200_e9ba97vf'}, /* model: 'TV01-ZB', vendor: 'Moes' */
             {modelID: 'TS0601', manufacturerName: '_TZE200_husqqvux'}, /* model: 'TSL-TRV-TV01ZG', vendor: 'Tesla Smart' */
+            {modelID: 'TS0601', manufacturerName: '_TZE200_lllliz3p'}, /* model: 'TV02-Zigbee', vendor: 'TuYa' */
         ],
         model: 'TV02-Zigbee',
         vendor: 'TuYa',
@@ -1716,9 +1717,7 @@ module.exports = [
         ],
     },
     {
-        fingerprint: [
-            {modelID: 'TS0601', manufacturerName: '_TZE200_vrfecyku'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_lu01t0zl'}],
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_vrfecyku'}],
         model: 'MIR-HE200-TY',
         vendor: 'TuYa',
         description: 'Human presence sensor',
@@ -1735,6 +1734,35 @@ module.exports = [
                 .withDescription('presets for sensitivity for presence and movement'),
         ],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_lu01t0zl'}],
+        model: 'MIR-HE200-TY_fall',
+        vendor: 'TuYa',
+        description: 'Human presence sensor with fall function',
+        fromZigbee: [fz.tuya_radar_sensor_fall],
+        toZigbee: [tz.tuya_radar_sensor_fall],
+        exposes: [
+            e.illuminance_lux(), e.presence(), e.occupancy(),
+            exposes.numeric('motion_speed', ea.STATE).withDescription('Speed of movement'),
+            exposes.enum('motion_direction', ea.STATE, Object.values(tuya.tuyaRadar.motionDirection))
+                .withDescription('direction of movement from the point of view of the radar'),
+            exposes.numeric('radar_sensitivity', ea.STATE_SET).withValueMin(0).withValueMax(10).withValueStep(1)
+                .withDescription('sensitivity of the radar'),
+            exposes.enum('radar_scene', ea.STATE_SET, Object.values(tuya.tuyaRadar.radarScene))
+                .withDescription('presets for sensitivity for presence and movement'),
+            exposes.enum('tumble_switch', ea.STATE_SET, ['ON', 'OFF']).withDescription('Tumble status switch'),
+            exposes.numeric('fall_sensitivity', ea.STATE_SET).withValueMin(1).withValueMax(10).withValueStep(1)
+                .withDescription('fall sensitivity of the radar'),
+            exposes.numeric('tumble_alarm_time', ea.STATE_SET).withValueMin(1).withValueMax(5).withValueStep(1)
+                .withUnit('min').withDescription('tumble alarm time'),
+            exposes.binary('fall_down_status', ea.STATE).withDescription('fall down status'),
+            exposes.text('static_dwell_alarm', ea.STATE).withDescription('static dwell alarm'),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await tuya.sendDataPointEnum(endpoint, tuya.dataPoints.trsfTumbleSwitch, false);
+        },
+    },
     {
         fingerprint: [{modelID: 'TS004F', manufacturerName: '_TZ3000_pcqjmcud'}],
         model: 'YSR-MINI-Z',
@@ -1874,4 +1902,13 @@ module.exports = [
         toZigbee: [],
         exposes: [e.contact(), e.battery(), e.vibration()],
     },
+    {
+        fingerprint: [{modelID: `TS0601`, manufacturerName: `_TZE200_yi4jtqq1`}],
+        model: `XFY-CGQ-ZIGB`,
+        vendor: `TuYa`,
+        description: `Illuminance sensor`,
+        fromZigbee: [fz.tuya_illuminance_sensor],
+        toZigbee: [],
+        exposes: [e.illuminance_lux(), e.brightness_state()],
+    },
 ];

package/devices/urlighting.js

@@ -0,0 +1,12 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3210_dn5higyl'}],
+        model: 'TH008L10RGBCCT',
+        vendor: 'UR Lighting',
+        description: '10W RGB+CCT downlight',
+        meta: {applyRedFix: true, enhancedHue: false},
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+    },
+];

package/lib/exposes.js

@@ -543,6 +543,7 @@ module.exports = {
         humidity: () => new Numeric('humidity', access.STATE).withUnit('%').withDescription('Measured relative humidity'),
         illuminance: () => new Numeric('illuminance', access.STATE).withDescription('Raw measured illuminance'),
         illuminance_lux: () => new Numeric('illuminance_lux', access.STATE).withUnit('lx').withDescription('Measured illuminance in lux'),
+        brightness_state: () => new Enum('brightness_state', access.STATE, ['low', 'middle', 'high', 'strong']).withDescription('Brightness state'),
         keypad_lockout: () => new Enum('keypad_lockout', access.ALL, ['unlock', 'lock1', 'lock2']).withDescription('Enables/disables physical input on the device'),
         led_disabled_night: () => new Binary('led_disabled_night', access.ALL, true, false).withDescription('Enable/disable the LED at night'),
         light_brightness: () => new Light().withBrightness(),

package/lib/ota/common.js

@@ -385,11 +385,18 @@ async function updateToLatest(device, logger, onProgress, getNewImage, getImageM
 
                 endpoint.commandResponse('genOta', 'upgradeEndResponse', payload).then(
                     () => {
-                        logger.debug(`Update succeeded, waiting for device to restart`);
-                        setTimeout(() => {
-                            onProgress(100, null);
+                        logger.debug(`Update succeeded, waiting for device announce`);
+                        onProgress(100, null);
+
+                        let timer = null;
+                        const cb = () => {
+                            logger.debug('Got device announce or timed out, call resolve');
+                            clearInterval(timer);
+                            device.removeListener('deviceAnnounce', cb);
                             resolve();
-                        }, 90 * 1000);
+                        };
+                        timer = setTimeout(cb, 120 * 1000); // timeout after 2 minutes
+                        device.once('deviceAnnounce', cb);
                     },
                     (e) => {
                         const message = `Upgrade end reponse failed (${e.message})`;

package/lib/tuya.js

@@ -426,6 +426,19 @@ const dataPoints = {
     trsScene: 112,
     trsMotionDirection: 114,
     trsMotionSpeed: 115,
+    // TuYa Radar Sensor with fall function
+    trsfPresenceState: 1,
+    trsfSensitivity: 2,
+    trsfMotionState: 102,
+    trsfIlluminanceLux: 103,
+    trsfTumbleSwitch: 105,
+    trsfTumbleAlarmTime: 106,
+    trsfScene: 112,
+    trsfMotionDirection: 114,
+    trsfMotionSpeed: 115,
+    trsfFallDownStatus: 116,
+    trsfStaticDwellAlarm: 117,
+    trsfFallSensitivity: 118,
     // Human Presence Sensor AIR
     msVSensitivity: 101,
     msOSensitivity: 102,
@@ -524,6 +537,7 @@ const dataPoints = {
     // TUYA / HUMIDITY/ILLUMINANCE/TEMPERATURE SENSOR
     thitBatteryPercentage: 3,
     thitIlluminanceLux: 7,
+    tIlluminanceLux: 2,
     thitHumidity: 9,
     thitTemperature: 8,
     // TUYA SMART VIBRATION SENSOR

package/npm-shrinkwrap.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.387",
+  "version": "14.0.391",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.387",
+  "version": "14.0.391",
   "description": "Collection of device converters to be used with zigbee-herdsman",
   "main": "index.js",
   "files": [