zigbee-herdsman-converters 20.12.1 → 20.14.0

package/converters/toZigbee.d.ts

@@ -1,5 +1,5 @@
 import * as exposes from '../lib/exposes';
-import { Tz, KeyValueAny } from '../lib/types';
+import { KeyValueAny, Tz } from '../lib/types';
 declare const converters: {
     light_onoff_restorable_brightness: {
         /**

package/converters/toZigbee.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toZigbee.d.ts","sourceRoot":"","sources":["../src/converters/toZigbee.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAK1C,OAAO,EAAC,EAAE,EAAY,WAAW,EAAC,MAAM,cAAc,CAAC;AA65IvD,QAAA,MAAM,UAAU;;QAlKR;;;WAGG;;;;mBApnG8B,WAAW;;;;;;;;;mBAAX,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAX,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAX,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAX,WAAW;;;;;;;;;;;;;;;QA4C5C;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mKAywEoC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm9BS,CAAC;AAEpE,eAAe,UAAU,CAAC"}
+{"version":3,"file":"toZigbee.d.ts","sourceRoot":"","sources":["../src/converters/toZigbee.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAK1C,OAAO,EAAW,WAAW,EAAE,EAAE,EAAC,MAAM,cAAc,CAAC;AA45IvD,QAAA,MAAM,UAAU;;QAlKR;;;WAGG;;;;mBApnG8B,WAAW;;;;;;;;;mBAAX,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAX,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAX,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAX,WAAW;;;;;;;;;;;;;;;QA4C5C;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mKAywEoC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm9BS,CAAC;AAEpE,eAAe,UAAU,CAAC"}

package/converters/toZigbee.js

@@ -52,9 +52,9 @@ const converters1 = {
         convertSet: async (entity, key, value, meta) => {
             const state = utils.isString(meta.message.state) ? meta.message.state.toLowerCase() : null;
             utils.validateValue(state, ['toggle', 'off', 'on']);
-            if (state === 'on' && (meta.message.hasOwnProperty('on_time') || meta.message.hasOwnProperty('off_wait_time'))) {
-                const onTime = meta.message.hasOwnProperty('on_time') ? meta.message.on_time : 0;
-                const offWaitTime = meta.message.hasOwnProperty('off_wait_time') ? meta.message.off_wait_time : 0;
+            if (state === 'on' && (meta.message.on_time !== undefined || meta.message.off_wait_time !== undefined)) {
+                const onTime = meta.message.on_time !== undefined ? meta.message.on_time : 0;
+                const offWaitTime = meta.message.off_wait_time !== undefined ? meta.message.off_wait_time : 0;
                 if (typeof onTime !== 'number') {
                     throw Error('The on_time value must be a number!');
                 }
@@ -122,7 +122,7 @@ const converters1 = {
                     else {
                         zclData.hue = utils.mapNumberRange(hsvCorrected.hue, 0, 360, 0, 254);
                     }
-                    // @ts-expect-error
+                    // @ts-expect-error ignore
                     zclData.direction = value.direction || 0;
                 }
                 if (hsv.saturation != null) {
@@ -130,7 +130,7 @@ const converters1 = {
                 }
                 if (hsv.value !== null) {
                     // fallthrough to genLevelCtrl
-                    // @ts-expect-error
+                    // @ts-expect-error ignore
                     value.brightness = utils.mapNumberRange(hsvCorrected.value, 0, 100, 0, 254);
                 }
                 if (hsv.hue !== null && hsv.saturation !== null) {
@@ -153,10 +153,8 @@ const converters1 = {
                     command = 'moveToSaturation';
                 }
             }
-            if (value.hasOwnProperty('brightness')) {
-                await entity.command('genLevelCtrl', 'moveToLevelWithOnOff', 
-                // @ts-expect-error
-                { level: Number(value.brightness), transtime: utils.getTransition(entity, key, meta).time }, utils.getOptions(meta.mapped, entity));
+            if (utils.isObject(value) && value.brightness !== undefined) {
+                await entity.command('genLevelCtrl', 'moveToLevelWithOnOff', { level: Number(value.brightness), transtime: utils.getTransition(entity, key, meta).time }, utils.getOptions(meta.mapped, entity));
             }
             await entity.command('lightingColorCtrl', command, zclData, utils.getOptions(meta.mapped, entity));
             return { state: libColor.syncColorState(newState, meta.state, entity, meta.options), readAfterWriteTime: zclData.transtime * 100 };
@@ -202,9 +200,9 @@ const converters2 = {
         key: ['read'],
         convertSet: async (entity, key, value, meta) => {
             utils.assertObject(value, key);
-            const result = await entity.read(value.cluster, value.attributes, value.hasOwnProperty('options') ? value.options : {});
+            const result = await entity.read(value.cluster, value.attributes, value.options !== undefined ? value.options : {});
             logger_1.logger.info(`Read result of '${value.cluster}': ${JSON.stringify(result)}`, NS);
-            if (value.hasOwnProperty('state_property')) {
+            if (value.state_property !== undefined) {
                 return { state: { [value.state_property]: result } };
             }
         },
@@ -214,7 +212,7 @@ const converters2 = {
         convertSet: async (entity, key, value, meta) => {
             utils.assertObject(value, key);
             const options = utils.getOptions(meta.mapped, entity);
-            if (value.hasOwnProperty('options')) {
+            if (value.options !== undefined) {
                 Object.assign(options, value.options);
             }
             await entity.write(value.cluster, value.payload, options);
@@ -226,7 +224,7 @@ const converters2 = {
         convertSet: async (entity, key, value, meta) => {
             utils.assertObject(value, key);
             const options = utils.getOptions(meta.mapped, entity);
-            await entity.command(value.cluster, value.command, value.hasOwnProperty('payload') ? value.payload : {}, options);
+            await entity.command(value.cluster, value.command, value.payload !== undefined ? value.payload : {}, options);
             logger_1.logger.info(`Invoked '${value.cluster}.${value.command}' with payload '${JSON.stringify(value.payload)}'`, NS);
         },
     },
@@ -249,9 +247,9 @@ const converters2 = {
         key: ['zclcommand'],
         convertSet: async (entity, key, value, meta) => {
             utils.assertObject(value, key);
-            const payload = value.hasOwnProperty('payload') ? value.payload : {};
+            const payload = value.payload !== undefined ? value.payload : {};
             utils.assertEndpoint(entity);
-            await entity.zclCommand(value.cluster, value.command, payload, value.hasOwnProperty('options') ? value.options : {});
+            await entity.zclCommand(value.cluster, value.command, payload, value.options !== undefined ? value.options : {});
             logger_1.logger.info(`Invoked ZCL command ${value.cluster}.${value.command} with payload '${JSON.stringify(payload)}'`, NS);
         },
     },
@@ -262,7 +260,7 @@ const converters2 = {
             utils.assertObject(value, key);
             if (Array.isArray(meta.mapped))
                 throw new Error(`Not supported for groups`);
-            const isNotification = value.hasOwnProperty('transaction');
+            const isNotification = value.transaction !== undefined;
             const modeSrc = isNotification ? constants.armNotification : constants.armMode;
             const mode = utils.getKey(modeSrc, value.mode, undefined, Number);
             if (mode === undefined) {
@@ -319,7 +317,7 @@ const converters2 = {
         key: ['color_options'],
         convertSet: async (entity, key, value, meta) => {
             utils.assertObject(value, key);
-            const options = value.hasOwnProperty('execute_if_off') && value.execute_if_off ? 1 : 0;
+            const options = value.execute_if_off !== undefined && value.execute_if_off ? 1 : 0;
             await entity.write('lightingColorCtrl', { options }, utils.getOptions(meta.mapped, entity));
             return { state: { color_options: value } };
         },
@@ -366,7 +364,7 @@ const converters2 = {
             utils.assertObject(value, key);
             const user = value.user;
             const userType = value.user_type || 'unrestricted';
-            const userEnabled = value.hasOwnProperty('user_enabled') ? value.user_enabled : true;
+            const userEnabled = value.user_enabled !== undefined ? value.user_enabled : true;
             const pinCode = value.pin_code;
             if (isNaN(user))
                 throw new Error('user must be numbers');
@@ -390,7 +388,7 @@ const converters2 = {
             }
         },
         convertGet: async (entity, key, meta) => {
-            // @ts-expect-error
+            // @ts-expect-error ignore
             const user = meta && meta.message && meta.message.pin_code ? meta.message.pin_code.user : undefined;
             if (user === undefined) {
                 const max = utils.getMetaValue(entity, meta.mapped, 'pinCodeCount');
@@ -434,7 +432,7 @@ const converters2 = {
             }, utils.getOptions(meta.mapped, entity));
         },
         convertGet: async (entity, key, meta) => {
-            // @ts-expect-error
+            // @ts-expect-error ignore
             const user = meta && meta.message && meta.message.user_status ? meta.message.user_status.user : undefined;
             const pinCodeCount = utils.getMetaValue(entity, meta.mapped, 'pinCodeCount');
             if (user === undefined) {
@@ -489,18 +487,18 @@ const converters2 = {
             const level = { low: 0, medium: 1, high: 2, very_high: 3 };
             const strobeLevel = { low: 0, medium: 1, high: 2, very_high: 3 };
             const values = {
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 mode: value.mode || 'emergency',
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 level: value.level || 'medium',
-                // @ts-expect-error
-                strobe: value.hasOwnProperty('strobe') ? value.strobe : true,
-                // @ts-expect-error
-                duration: value.hasOwnProperty('duration') ? value.duration : 10,
-                // @ts-expect-error
-                strobeDutyCycle: value.hasOwnProperty('strobe_duty_cycle') ? value.strobe_duty_cycle * 10 : 0,
-                // @ts-expect-error
-                strobeLevel: value.hasOwnProperty('strobe_level') ? utils.getFromLookup(value.strobe_level, strobeLevel) : 1,
+                // @ts-expect-error ignore
+                strobe: value.strobe !== undefined ? value.strobe : true,
+                // @ts-expect-error ignore
+                duration: value.duration !== undefined ? value.duration : 10,
+                // @ts-expect-error ignore
+                strobeDutyCycle: value.strobe_duty_cycle !== undefined ? value.strobe_duty_cycle * 10 : 0,
+                // @ts-expect-error ignore
+                strobeLevel: value.strobe_level !== undefined ? utils.getFromLookup(value.strobe_level, strobeLevel) : 1,
             };
             let info;
             // https://github.com/Koenkk/zigbee2mqtt/issues/8310 some devices require the info to be reversed.
@@ -551,7 +549,7 @@ const converters2 = {
             const values = {
                 state: value.state,
                 level: value.level || 'very_high',
-                strobe: value.hasOwnProperty('strobe') ? value.strobe : false,
+                strobe: value.strobe !== undefined ? value.strobe : false,
             };
             const info = utils.getFromLookup(values.state, state) + ((values.strobe ? 1 : 0) << 4) + (utils.getFromLookup(values.level, level) << 6);
             await entity.command('ssIasWd', 'squawk', { squawkinfo: info }, utils.getOptions(meta.mapped, entity));
@@ -632,13 +630,13 @@ const converters2 = {
                 try {
                     value = JSON.parse(value);
                 }
-                catch (e) {
+                catch {
                     throw new Error('Payload is not valid JSON');
                 }
             }
             utils.assertObject(value, key);
             // onOffTransitionTime - range 0x0000 to 0xffff - optional
-            if (value.hasOwnProperty('on_off_transition_time')) {
+            if (value.on_off_transition_time !== undefined) {
                 let onOffTransitionTimeValue = Number(value.on_off_transition_time);
                 if (onOffTransitionTimeValue > 65535)
                     onOffTransitionTimeValue = 65535;
@@ -649,7 +647,7 @@ const converters2 = {
             }
             // onTransitionTime - range 0x0000 to 0xffff - optional
             //                    0xffff = use onOffTransitionTime
-            if (value.hasOwnProperty('on_transition_time')) {
+            if (value.on_transition_time !== undefined) {
                 let onTransitionTimeValue = value.on_transition_time;
                 if (typeof onTransitionTimeValue === 'string' && onTransitionTimeValue.toLowerCase() == 'disabled') {
                     onTransitionTimeValue = 65535;
@@ -670,7 +668,7 @@ const converters2 = {
             }
             // offTransitionTime - range 0x0000 to 0xffff - optional
             //                    0xffff = use onOffTransitionTime
-            if (value.hasOwnProperty('off_transition_time')) {
+            if (value.off_transition_time !== undefined) {
                 let offTransitionTimeValue = value.off_transition_time;
                 if (typeof offTransitionTimeValue === 'string' && offTransitionTimeValue.toLowerCase() == 'disabled') {
                     offTransitionTimeValue = 65535;
@@ -692,7 +690,7 @@ const converters2 = {
             // startUpCurrentLevel - range 0x00 to 0xff - optional
             //                       0x00 = return to minimum supported level
             //                       0xff = return to previous previous
-            if (value.hasOwnProperty('current_level_startup')) {
+            if (value.current_level_startup !== undefined) {
                 let startUpCurrentLevelValue = value.current_level_startup;
                 if (typeof startUpCurrentLevelValue === 'string' && startUpCurrentLevelValue.toLowerCase() == 'previous') {
                     startUpCurrentLevelValue = 255;
@@ -719,7 +717,7 @@ const converters2 = {
             }
             // onLevel - range 0x00 to 0xff - optional
             //           Any value outside of MinLevel to MaxLevel, including 0xff and 0x00, is interpreted as "previous".
-            if (value.hasOwnProperty('on_level')) {
+            if (value.on_level !== undefined) {
                 let onLevel = value.on_level;
                 if (typeof onLevel === 'string' && onLevel.toLowerCase() == 'previous') {
                     onLevel = 255;
@@ -739,7 +737,7 @@ const converters2 = {
             //          when 1, CurrentLevel can be changed while the device is off.
             //   bit 1: CoupleColorTempToLevel - when 1, changes to level also change color temperature.
             //          (What this means is not defined, but it's most likely to be "dim to warm".)
-            if (value.hasOwnProperty('execute_if_off')) {
+            if (value.execute_if_off !== undefined) {
                 const executeIfOffValue = !!value.execute_if_off;
                 await entity.write('genLevelCtrl', { options: executeIfOffValue ? 1 : 0 }, utils.getOptions(meta.mapped, entity));
                 Object.assign(state, { execute_if_off: executeIfOffValue });
@@ -753,7 +751,7 @@ const converters2 = {
                 try {
                     await entity.read('genLevelCtrl', [attribute]);
                 }
-                catch (ex) {
+                catch {
                     // continue regardless of error, all these are optional in ZCL
                 }
             }
@@ -800,10 +798,10 @@ const converters2 = {
                 'lamp_burn_hours_trip_point',
             ]) {
                 try {
-                    // @ts-expect-error
+                    // @ts-expect-error ignore
                     result = { ...result, ...(await entity.read('lightingBallastCfg', [utils.toCamelCase(attrName)])) };
                 }
-                catch (ex) {
+                catch {
                     // continue regardless of error
                 }
             }
@@ -824,7 +822,7 @@ const converters2 = {
             const transition = utils.getTransition(entity, key, meta).time;
             const payload = { stepmode: mode, stepsize: Math.abs(value), transtime: transition };
             await entity.command('genLevelCtrl', command, payload, utils.getOptions(meta.mapped, entity));
-            if (meta.state.hasOwnProperty('brightness')) {
+            if (meta.state.brightness !== undefined) {
                 utils.assertNumber(meta.state.brightness);
                 let brightness = onOff || meta.state.state === 'ON' ? meta.state.brightness + value : meta.state.brightness;
                 if (value === 0) {
@@ -920,7 +918,7 @@ const converters2 = {
                 const stop = (val) => ['stop', 'release', '0'].some((el) => val.includes(el));
                 const up = (val) => ['1', 'up'].some((el) => val.includes(el));
                 const arr = [value.toString()];
-                const moverate = meta.message.hasOwnProperty('rate') ? Number(meta.message.rate) : 55;
+                const moverate = meta.message.rate !== undefined ? Number(meta.message.rate) : 55;
                 payload.rate = moverate;
                 if (arr.filter(stop).length) {
                     payload.movemode = 0;
@@ -1014,12 +1012,12 @@ const converters2 = {
             const { message } = meta;
             const transition = utils.getTransition(entity, 'brightness', meta);
             const turnsOffAtBrightness1 = utils.getMetaValue(entity, meta.mapped, 'turnsOffAtBrightness1', 'allEqual', false);
-            let state = message.hasOwnProperty('state') ? (typeof message.state === 'string' ? message.state.toLowerCase() : null) : undefined;
+            let state = message.state !== undefined ? (typeof message.state === 'string' ? message.state.toLowerCase() : null) : undefined;
             let brightness = undefined;
-            if (message.hasOwnProperty('brightness')) {
+            if (message.brightness !== undefined) {
                 brightness = Number(message.brightness);
             }
-            else if (message.hasOwnProperty('brightness_percent')) {
+            else if (message.brightness_percent !== undefined) {
                 brightness = utils.mapNumberRange(Number(message.brightness_percent), 0, 100, 0, 255);
             }
             if (brightness === 255) {
@@ -1055,7 +1053,7 @@ const converters2 = {
                     logger_1.logger.debug(`Supressing OFF transition since entity has noOffTransition=true`, NS);
                     brightness = undefined;
                 }
-                if (meta.state.hasOwnProperty('brightness') && meta.state.state === 'ON') {
+                if (meta.state.brightness !== undefined && meta.state.state === 'ON') {
                     // The light's current level gets clobbered in two cases:
                     //   1. when 'Off' has a transition, in which case it is really 'MoveToLevelWithOnOff'
                     //      https://github.com/Koenkk/zigbee-herdsman-converters/issues/1073
@@ -1079,11 +1077,11 @@ const converters2 = {
                         try {
                             const attributeRead = await entity.read('genLevelCtrl', ['onLevel']);
                             if (attributeRead !== undefined) {
-                                // @ts-expect-error
+                                // @ts-expect-error ignore
                                 onLevel = attributeRead['onLevel'];
                             }
                         }
-                        catch (e) {
+                        catch {
                             // OnLevel not supported
                         }
                     }
@@ -1288,10 +1286,10 @@ const converters2 = {
                 // transform transition payload values if needed
                 for (const elem of payload.transitions) {
                     // update payload.mode if needed
-                    if (elem.hasOwnProperty('heatSetpoint') && !payload.mode.includes('heat')) {
+                    if (elem.heatSetpoint !== undefined && !payload.mode.includes('heat')) {
                         payload.mode.push('heat');
                     }
-                    if (elem.hasOwnProperty('coolSetpoint') && !payload.mode.includes('cool')) {
+                    if (elem.coolSetpoint !== undefined && !payload.mode.includes('cool')) {
                         payload.mode.push('cool');
                     }
                     // transform setpoint values if numeric
@@ -1314,7 +1312,7 @@ const converters2 = {
                         }
                     }
                     else if (typeof elem['transitionTime'] === 'object') {
-                        if (!elem['transitionTime'].hasOwnProperty('hour') || !elem['transitionTime'].hasOwnProperty('minute')) {
+                        if (elem['transitionTime'].hour === undefined || elem['transitionTime'].minute === undefined) {
                             throw new Error('weekly_schedule: expected 24h time object (e.g. {"hour": 19, "minute": 30}), ' +
                                 `but got '${JSON.stringify(elem['transitionTime'])}'!`);
                         }
@@ -1349,7 +1347,7 @@ const converters2 = {
                 let dayofweek = 0;
                 for (let d of payload.dayofweek) {
                     if (typeof d === 'object') {
-                        if (!d.hasOwnProperty('day')) {
+                        if (d.day === undefined) {
                             throw new Error('weekly_schedule: expected dayofweek to be string or {"day": "str"}, ' + `but got '${JSON.stringify(d)}'!`);
                         }
                         d = d.day;
@@ -2096,7 +2094,7 @@ const converters2 = {
                 writeUndiv: true,
                 transactionSequenceNumber: 0xe9,
             };
-            if (value.hasOwnProperty('motor_direction')) {
+            if (value.motor_direction !== undefined) {
                 let direction;
                 switch (value.motor_direction) {
                     case 'FORWARD':
@@ -2112,7 +2110,7 @@ const converters2 = {
                 const payload = { 0x1301: { value: [direction, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] } };
                 await entity.write('genPowerCfg', payload, options);
             }
-            if (value.hasOwnProperty('motor_speed')) {
+            if (value.motor_speed !== undefined) {
                 if (value.motor_speed < 20 || value.motor_speed > 40) {
                     throw new Error('livolo_cover_options: Motor speed is out of range (20-40)');
                 }
@@ -2169,7 +2167,7 @@ const converters2 = {
             utils.assertString(value, key);
             utils.validateValue(value, ['toggle', 'off', 'on']);
             if (value === 'toggle') {
-                if (!meta.state.hasOwnProperty('state')) {
+                if (meta.state.state === undefined) {
                     throw new Error('Cannot toggle, state not known yet');
                 }
                 else {
@@ -2495,9 +2493,9 @@ const converters2 = {
         key: ['position', 'tilt'],
         convertSet: async (entity, key, value, meta) => {
             utils.assertNumber(value, key);
-            if (meta.options.hasOwnProperty('time_close') && meta.options.hasOwnProperty('time_open')) {
+            if (meta.options.time_close !== undefined && meta.options.time_open !== undefined) {
                 const sleepSeconds = async (s) => {
-                    return new Promise((resolve) => setTimeout(resolve, s * 1000));
+                    return await new Promise((resolve) => setTimeout(resolve, s * 1000));
                 };
                 const oldPosition = meta.state.position;
                 if (value == 100) {
@@ -2693,8 +2691,8 @@ const converters2 = {
         convertSet: async (entity, key, value, meta) => {
             if (key === 'brightness' &&
                 meta.state.color_mode == constants.colorModeLookup[2] &&
-                !meta.message.hasOwnProperty('color') &&
-                !meta.message.hasOwnProperty('color_temp')) {
+                meta.message.color === undefined &&
+                meta.message.color_temp === undefined) {
                 const zclData = { level: Number(value), transtime: 0 };
                 await entity.command('genLevelCtrl', 'moveToLevel', zclData, utils.getOptions(meta.mapped, entity));
                 globalStore.putValue(entity, 'brightness', zclData.level);
@@ -2730,9 +2728,9 @@ const converters2 = {
             }
             const zclData = {
                 brightness: globalStore.getValue(entity, 'brightness') || 100,
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 hue: utils.mapNumberRange(meta.state.color.h, 0, 360, 0, 254) || 100,
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 saturation: utils.mapNumberRange(meta.state.color.s, 0, 100, 0, 254) || 100,
                 transtime: 0,
             };
@@ -2759,7 +2757,7 @@ const converters2 = {
                     zclData.brightness = value;
                 }
             }
-            if (meta.message.hasOwnProperty('color')) {
+            if (meta.message.color !== undefined) {
                 if (utils.isObject(meta.message.color)) {
                     if (meta.message.color.h) {
                         zclData.hue = utils.mapNumberRange(meta.message.color.h, 0, 360, 0, 254);
@@ -3290,7 +3288,7 @@ const converters2 = {
             };
             let value = utils.getFromLookup(rawValue, lookup, Number(rawValue));
             if (key == 'sensors_type') {
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 value = utils.getFromLookup(rawValue, sensorsTypeLookup, Number(rawValue));
             }
             const payloads = {
@@ -3357,7 +3355,7 @@ const converters2 = {
             const modeOpenLookup = { never: '0', once: '1', always: '2', drop: '3' };
             let value = utils.getFromLookup(rawValue, lookup, Number(rawValue));
             if (key == 'mode') {
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 value = utils.getFromLookup(rawValue, modeOpenLookup, Number(rawValue));
             }
             const payloads = {
@@ -3426,7 +3424,7 @@ const converters2 = {
             const options = {
                 // Don't send a manufacturerCode (otherwise set in herdsman):
                 // https://github.com/Koenkk/zigbee-herdsman-converters/pull/2827
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 manufacturerCode: null,
                 ...utils.getOptions(meta.mapped, entity),
             };
@@ -3479,13 +3477,13 @@ const converters2 = {
                         utils.saveSceneState(member, sceneid, groupid, meta.membersState[member.getDevice().ieeeAddr], scenename);
                     }
                 }
-                // @ts-expect-error
+                // @ts-expect-error ignore
             }
             else if (response.status === 0) {
                 utils.saveSceneState(entity, sceneid, groupid, meta.state, scenename);
             }
             else {
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 throw new Error(`Scene add not successful ('${zigbee_herdsman_1.Zcl.Status[response.status]}')`);
             }
             logger_1.logger.info('Successfully stored scene', NS);
@@ -3500,11 +3498,11 @@ const converters2 = {
             const sceneid = value;
             await entity.command('genScenes', 'recall', { groupid, sceneid }, utils.getOptions(meta.mapped, entity));
             const addColorMode = (newState) => {
-                if (newState.hasOwnProperty('color_temp')) {
+                if (newState.color_temp !== undefined) {
                     newState.color_mode = constants.colorModeLookup[2];
                 }
-                else if (newState.hasOwnProperty('color')) {
-                    if (newState.color.hasOwnProperty('x')) {
+                else if (newState.color !== undefined) {
+                    if (newState.color.x !== undefined) {
                         newState.color_mode = constants.colorModeLookup[1];
                     }
                     else {
@@ -3519,7 +3517,7 @@ const converters2 = {
                     let recalledState = utils.getSceneState(member, sceneid, groupid);
                     if (recalledState) {
                         // add color_mode if saved state does not contain it
-                        if (!recalledState.hasOwnProperty('color_mode')) {
+                        if (recalledState.color_mode === undefined) {
                             recalledState = addColorMode(recalledState);
                         }
                         Object.assign(recalledState, libColor.syncColorState(recalledState, meta.state, entity, meta.options));
@@ -3537,7 +3535,7 @@ const converters2 = {
                 let recalledState = utils.getSceneState(entity, sceneid, groupid);
                 if (recalledState) {
                     // add color_mode if saved state does not contain it
-                    if (!recalledState.hasOwnProperty('color_mode')) {
+                    if (recalledState.color_mode === undefined) {
                         recalledState = addColorMode(recalledState);
                     }
                     Object.assign(recalledState, libColor.syncColorState(recalledState, meta.state, entity, meta.options));
@@ -3711,13 +3709,13 @@ const converters2 = {
                         utils.deleteSceneState(member, sceneid, groupid);
                     }
                 }
-                // @ts-expect-error
+                // @ts-expect-error ignore
             }
             else if (response.status === 0) {
                 utils.deleteSceneState(entity, sceneid, groupid);
             }
             else {
-                // @ts-expect-error
+                // @ts-expect-error ignore
                 throw new Error(`Scene remove not successful ('${zigbee_herdsman_1.Zcl.Status[response.status]}')`);
             }
             logger_1.logger.info('Successfully removed scene', NS);
@@ -3752,7 +3750,7 @@ const converters2 = {
             const isGroup = utils.isGroup(entity);
             const sceneid = value.ID;
             const scenename = value.name;
-            const groupid = isGroup ? entity.groupID : value.hasOwnProperty('group_id') ? value.group_id : 0;
+            const groupid = isGroup ? entity.groupID : value.group_id !== undefined ? value.group_id : 0;
             if (isGroup) {
                 if (meta.membersState) {
                     for (const member of entity.members) {
@@ -4238,7 +4236,7 @@ const converters3 = {
             const deviceState = meta.state || {};
             const message = meta.message;
             const state = utils.isString(message.state) ? message.state.toLowerCase() : null;
-            const hasBrightness = message.hasOwnProperty('brightness') || message.hasOwnProperty('brightness_percent');
+            const hasBrightness = message.brightness !== undefined || message.brightness_percent !== undefined;
             // Add brightness if command is 'on' and we can restore previous value
             if (state === 'on' && !hasBrightness && utils.isNumber(deviceState.brightness) && deviceState.brightness > 0) {
                 message.brightness = deviceState.brightness;
@@ -4308,10 +4306,10 @@ const converters3 = {
             if (entity.supportsInputCluster(cluster) || entity.supportsOutputCluster(cluster)) {
                 const message = meta.message;
                 let brightness = undefined;
-                if (message.hasOwnProperty('brightness')) {
+                if (message.brightness !== undefined) {
                     brightness = Number(message.brightness);
                 }
-                else if (message.hasOwnProperty('brightness_percent'))
+                else if (message.brightness_percent !== undefined)
                     brightness = Math.round(Number(message.brightness_percent) * 2.55);
                 if (brightness !== undefined && brightness === 0) {
                     message.state = 'off';
@@ -4365,10 +4363,10 @@ const converters3 = {
         key: ['state', 'brightness'],
         convertSet: async (entity, key, value, meta) => {
             const { message, state } = meta;
-            if (message.state === 'OFF' || (message.hasOwnProperty('state') && !message.hasOwnProperty('brightness'))) {
+            if (message.state === 'OFF' || (message.state !== undefined && message.brightness === undefined)) {
                 return await converters1.on_off.convertSet(entity, key, value, meta);
             }
-            else if (message.hasOwnProperty('brightness')) {
+            else if (message.brightness !== undefined) {
                 // set brightness
                 if (state.state === 'OFF') {
                     await entity.command('genOnOff', 'on', {}, utils.getOptions(meta.mapped, entity));
@@ -4395,7 +4393,7 @@ const converters3 = {
                 // https://github.com/Koenkk/zigbee2mqtt/issues/15902#issuecomment-1382848150
                 await entity.command('genOnOff', 'on', {}, utils.getOptions(meta.mapped, entity));
             }
-            return converters2.light_onoff_brightness.convertSet(entity, key, value, meta);
+            return await converters2.light_onoff_brightness.convertSet(entity, key, value, meta);
         },
     },
 };