zigbee-herdsman-converters 17.1.1 → 18.0.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [18.0.0](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v17.1.1...v18.0.0) (2023-12-26)
+
+
+### ⚠ BREAKING CHANGES
+
+* Improve consistency of calibrate and precision round options ([#6769](https://github.com/Koenkk/zigbee-herdsman-converters/issues/6769))
+
+### Features
+
+* Improve consistency of calibrate and precision round options ([#6769](https://github.com/Koenkk/zigbee-herdsman-converters/issues/6769)) ([204ee90](https://github.com/Koenkk/zigbee-herdsman-converters/commit/204ee901a06953d43762f75b9973c0ab4c9cdc0d))
+
+
+### Bug Fixes
+
+* Fix power source/type for Xiaomi QBKG20LM https://github.com/Koenkk/zigbee2mqtt/issues/20384 ([340228b](https://github.com/Koenkk/zigbee-herdsman-converters/commit/340228b79c44bbac22475bea298ef86039968395))
+* Fix set upper/bottom limit expose for TuYa TS0601_cover_4 https://github.com/Koenkk/zigbee2mqtt/issues/19690 ([bb4a44f](https://github.com/Koenkk/zigbee-herdsman-converters/commit/bb4a44f46181cb561661e0de206edb3463571e7c))
+* **ignore:** Fix configure for SONOFF BASICZBR3 failing ([4e5f3ec](https://github.com/Koenkk/zigbee-herdsman-converters/commit/4e5f3ec6a016d67fcc637f772bbfde7e488253e1))
+* Support OTA for TuYa TS110E_1gang_2 [@mrmaximas](https://github.com/mrmaximas) https://github.com/Koenkk/zigbee2mqtt/issues/18702 ([0ad15d9](https://github.com/Koenkk/zigbee-herdsman-converters/commit/0ad15d9f58a7d75e9611b9531401243dcc052f9d))
+
 ## [17.1.1](https://github.com/Koenkk/zigbee-herdsman-converters/compare/v17.1.0...v17.1.1) (2023-12-26)
 
 

package/README.md

@@ -4,6 +4,9 @@
 Collection of device converters to be used with zigbee-herdsman.
 
 ## Breaking changes
+18.0.0
+- After converting a message with a fromZigbee converter, `postProcessConvertedFromZigbeeMessage` should be called now (for applying calibration/precision)
+
 17.0.0
 - Various methods in `index.ts` are now async and return a `Promise`
 

package/converters/fromZigbee.d.ts

@@ -1,4 +1,4 @@
-import { Fz, KeyValueAny, Option } from '../lib/types';
+import { Fz, KeyValueAny } from '../lib/types';
 import * as exposes from '../lib/exposes';
 declare const converters: {
     command_arm_with_transaction: {
@@ -73,7 +73,6 @@ declare const converters: {
     RTCGQ11LM_illuminance: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => Promise<KeyValueAny>;
     };
     terncy_raw: {
@@ -186,7 +185,6 @@ declare const converters: {
     temperature: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             [x: string]: number;
         };
@@ -194,7 +192,6 @@ declare const converters: {
     device_temperature: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             device_temperature: number;
         };
@@ -202,7 +199,6 @@ declare const converters: {
     humidity: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             [x: string]: number;
         };
@@ -217,7 +213,6 @@ declare const converters: {
     soil_moisture: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             soil_moisture: number;
         };
@@ -225,16 +220,14 @@ declare const converters: {
     illuminance: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
-            illuminance: number;
+            illuminance: any;
             illuminance_lux: number;
         };
     };
     pressure: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             pressure: number;
         };
@@ -299,7 +292,6 @@ declare const converters: {
          */
         cluster: string;
         type: string[];
-        options: (definition: import("../lib/types").Definition) => Option[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => KeyValueAny;
     };
     electrical_measurement: {
@@ -309,7 +301,6 @@ declare const converters: {
          */
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => KeyValueAny;
     };
     on_off: {
@@ -948,7 +939,6 @@ declare const converters: {
     terncy_temperature: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             temperature: number;
         };
@@ -1300,7 +1290,6 @@ declare const converters: {
     lifecontrolVoc: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             temperature: number;
             humidity: number;
@@ -1346,7 +1335,6 @@ declare const converters: {
     _3310_humidity: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             humidity: number;
         };
@@ -1451,9 +1439,8 @@ declare const converters: {
     xiaomi_power: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
-            power: number;
+            power: any;
         };
     };
     xiaomi_on_off_action: {
@@ -1510,7 +1497,6 @@ declare const converters: {
     };
     xiaomi_temperature: {
         cluster: string;
-        options: exposes.Numeric[];
         type: string[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             temperature: number;
@@ -1663,9 +1649,8 @@ declare const converters: {
     keen_home_smart_vent_pressure: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
-            pressure: number;
+            pressure: any;
         };
     };
     U02I007C01_contact: {
@@ -2063,7 +2048,6 @@ declare const converters: {
     schneider_temperature: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             [x: string]: number;
         };
@@ -2174,7 +2158,6 @@ declare const converters: {
     SNZB02_temperature: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             [x: string]: number;
         };
@@ -2182,7 +2165,6 @@ declare const converters: {
     SNZB02_humidity: {
         cluster: string;
         type: string[];
-        options: exposes.Numeric[];
         convert: (model: import("../lib/types").Definition, msg: Fz.Message, publish: import("../lib/types").Publish, options: import("../lib/types").KeyValue, meta: Fz.Meta) => {
             humidity: number;
         };

package/converters/fromZigbee.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fromZigbee.d.ts","sourceRoot":"","sources":["../src/converters/fromZigbee.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,EAAE,EAAE,WAAW,EAAwB,MAAM,EAAC,MAAM,cAAc,CAAC;AAK3E,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAorM1C,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;QAhVR;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAprKH;;;WAGG;;;;;;;QAoDH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+HA4kGqC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sKAk/CC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA04BpB,CAAC;AAEpD,eAAe,UAAU,CAAC"}
+{"version":3,"file":"fromZigbee.d.ts","sourceRoot":"","sources":["../src/converters/fromZigbee.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,EAAE,EAAE,WAAW,EAAuB,MAAM,cAAc,CAAC;AAKnE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAwoM1C,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;QA/UR;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAlpKH;;;WAGG;;;;;;QAsCH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+HA6jGqC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sKA++CC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAu4BpB,CAAC;AAEpD,eAAe,UAAU,CAAC"}

package/converters/fromZigbee.js

@@ -395,30 +395,27 @@ const converters1 = {
     temperature: {
         cluster: 'msTemperatureMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature')],
         convert: (model, msg, publish, options, meta) => {
             if (msg.data.hasOwnProperty('measuredValue')) {
                 const temperature = parseFloat(msg.data['measuredValue']) / 100.0;
                 const property = (0, utils_1.postfixWithEndpointName)('temperature', msg, model, meta);
-                return { [property]: (0, utils_1.calibrateAndPrecisionRoundOptions)(temperature, options, 'temperature') };
+                return { [property]: temperature };
             }
         },
     },
     device_temperature: {
         cluster: 'genDeviceTempCfg',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.calibration('device_temperature')],
         convert: (model, msg, publish, options, meta) => {
             if (msg.data.hasOwnProperty('currentTemperature')) {
                 const value = parseInt(msg.data['currentTemperature']);
-                return { device_temperature: (0, utils_1.calibrateAndPrecisionRoundOptions)(value, options, 'device_temperature') };
+                return { device_temperature: value };
             }
         },
     },
     humidity: {
         cluster: 'msRelativeHumidity',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('humidity'), exposes.options.calibration('humidity')],
         convert: (model, msg, publish, options, meta) => {
             const humidity = parseFloat(msg.data['measuredValue']) / 100.0;
             const property = (0, utils_1.postfixWithEndpointName)('humidity', msg, model, meta);
@@ -426,7 +423,7 @@ const converters1 = {
             // Sometimes the sensor publishes non-realistic vales, it should only publish message
             // in the 0 - 100 range, don't produce messages beyond these values.
             if (humidity >= 0 && humidity <= 100) {
-                return { [property]: (0, utils_1.calibrateAndPrecisionRoundOptions)(humidity, options, 'humidity') };
+                return { [property]: humidity };
             }
         },
     },
@@ -442,30 +439,24 @@ const converters1 = {
     soil_moisture: {
         cluster: 'msSoilMoisture',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('soil_moisture'), exposes.options.calibration('soil_moisture')],
         convert: (model, msg, publish, options, meta) => {
             const soilMoisture = parseFloat(msg.data['measuredValue']) / 100.0;
-            return { soil_moisture: (0, utils_1.calibrateAndPrecisionRoundOptions)(soilMoisture, options, 'soil_moisture') };
+            return { soil_moisture: soilMoisture };
         },
     },
     illuminance: {
         cluster: 'msIlluminanceMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.calibration('illuminance', 'percentual'), exposes.options.calibration('illuminance_lux', 'percentual')],
         convert: (model, msg, publish, options, meta) => {
             // DEPRECATED: only return lux here (change illuminance_lux -> illuminance)
             const illuminance = msg.data['measuredValue'];
             const illuminanceLux = illuminance === 0 ? 0 : Math.pow(10, (illuminance - 1) / 10000);
-            return {
-                illuminance: (0, utils_1.calibrateAndPrecisionRoundOptions)(illuminance, options, 'illuminance'),
-                illuminance_lux: (0, utils_1.calibrateAndPrecisionRoundOptions)(illuminanceLux, options, 'illuminance_lux'),
-            };
+            return { illuminance: illuminance, illuminance_lux: illuminanceLux };
         },
     },
     pressure: {
         cluster: 'msPressureMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('pressure'), exposes.options.calibration('pressure')],
         convert: (model, msg, publish, options, meta) => {
             let pressure = 0;
             if (msg.data.hasOwnProperty('scaledValue')) {
@@ -475,7 +466,7 @@ const converters1 = {
             else {
                 pressure = parseFloat(msg.data['measuredValue']);
             }
-            return { pressure: (0, utils_1.calibrateAndPrecisionRoundOptions)(pressure, options, 'pressure') };
+            return { pressure };
         },
     },
     co2: {
@@ -682,19 +673,6 @@ const converters1 = {
          */
         cluster: 'seMetering',
         type: ['attributeReport', 'readResponse'],
-        // FIXME: Why are we expecting errors here? Sounds like a codesmell
-        options: (definition) => {
-            const result = [];
-            // @ts-expect-error
-            if (definition.exposes.find((e) => e.name === 'power')) {
-                result.push(exposes.options.precision('power'), exposes.options.calibration('power', 'percentual'));
-            }
-            // @ts-expect-error
-            if (definition.exposes.find((e) => e.name === 'energy')) {
-                result.push(exposes.options.precision('energy'), exposes.options.calibration('energy', 'percentual'));
-            }
-            return result;
-        },
         convert: (model, msg, publish, options, meta) => {
             if (utils.hasAlreadyProcessedMessage(msg, model))
                 return;
@@ -707,7 +685,7 @@ const converters1 = {
                 if (factor != null) {
                     power = (power * factor) * 1000; // kWh to Watt
                 }
-                payload.power = (0, utils_1.calibrateAndPrecisionRoundOptions)(power, options, 'power');
+                payload.power = power;
             }
             if (factor != null && (msg.data.hasOwnProperty('currentSummDelivered') ||
                 msg.data.hasOwnProperty('currentSummReceived'))) {
@@ -722,7 +700,7 @@ const converters1 = {
                     const value = (parseInt(data[0]) << 32) + parseInt(data[1]);
                     energy -= value * factor;
                 }
-                payload.energy = (0, utils_1.calibrateAndPrecisionRoundOptions)(energy, options, 'energy');
+                payload.energy = energy;
             }
             return payload;
         },
@@ -734,11 +712,6 @@ const converters1 = {
          */
         cluster: 'haElectricalMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [
-            exposes.options.calibration('power', 'percentual'), exposes.options.precision('power'),
-            exposes.options.calibration('current', 'percentual'), exposes.options.precision('current'),
-            exposes.options.calibration('voltage', 'percentual'), exposes.options.precision('voltage'),
-        ],
         convert: (model, msg, publish, options, meta) => {
             if (utils.hasAlreadyProcessedMessage(msg, model))
                 return;
@@ -768,7 +741,7 @@ const converters1 = {
                     const factor = getFactor(entry.factor);
                     const property = (0, utils_1.postfixWithEndpointName)(entry.name, msg, model, meta);
                     const value = msg.data[entry.key] * factor;
-                    payload[property] = (0, utils_1.calibrateAndPrecisionRoundOptions)(value, options, entry.name);
+                    payload[property] = value;
                 }
             }
             if (msg.data.hasOwnProperty('powerFactor')) {
@@ -2114,10 +2087,9 @@ const converters1 = {
     terncy_temperature: {
         cluster: 'msTemperatureMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature')],
         convert: (model, msg, publish, options, meta) => {
             const temperature = parseFloat(msg.data['measuredValue']) / 10.0;
-            return { temperature: (0, utils_1.calibrateAndPrecisionRoundOptions)(temperature, options, 'temperature') };
+            return { temperature: temperature };
         },
     },
     ts0216_siren: {
@@ -3443,18 +3415,12 @@ const converters1 = {
     lifecontrolVoc: {
         cluster: 'msTemperatureMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature'),
-            exposes.options.precision('humidity'), exposes.options.calibration('humidity')],
         convert: (model, msg, publish, options, meta) => {
             const temperature = parseFloat(msg.data['measuredValue']) / 100.0;
             const humidity = parseFloat(msg.data['minMeasuredValue']) / 100.0;
             const eco2 = parseFloat(msg.data['maxMeasuredValue']);
             const voc = parseFloat(msg.data['tolerance']);
-            return {
-                temperature: (0, utils_1.calibrateAndPrecisionRoundOptions)(temperature, options, 'temperature'),
-                humidity: (0, utils_1.calibrateAndPrecisionRoundOptions)(humidity, options, 'humidity'),
-                eco2, voc,
-            };
+            return { temperature, humidity, eco2, voc };
         },
     },
     _8840100H_water_leak_alarm: {
@@ -3522,10 +3488,9 @@ const converters1 = {
     _3310_humidity: {
         cluster: 'manuSpecificCentraliteHumidity',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('humidity'), exposes.options.calibration('humidity')],
         convert: (model, msg, publish, options, meta) => {
             const humidity = parseFloat(msg.data['measuredValue']) / 100.0;
-            return { humidity: (0, utils_1.calibrateAndPrecisionRoundOptions)(humidity, options, 'humidity') };
+            return { humidity };
         },
     },
     smartthings_acceleration: {
@@ -3716,9 +3681,8 @@ const converters1 = {
     xiaomi_power: {
         cluster: 'genAnalogInput',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.calibration('power', 'percentual'), exposes.options.precision('power')],
         convert: (model, msg, publish, options, meta) => {
-            return { power: (0, utils_1.calibrateAndPrecisionRoundOptions)(msg.data['presentValue'], options, 'power') };
+            return { power: msg.data['presentValue'] };
         },
     },
     xiaomi_on_off_action: {
@@ -3796,8 +3760,7 @@ const converters1 = {
         // Therefore we need to publish the no_motion detected by ourselves.
         cluster: 'aqaraOpple',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.occupancy_timeout_2(), exposes.options.no_occupancy_since_true(),
-            exposes.options.calibration('illuminance', 'percentual')],
+        options: [exposes.options.occupancy_timeout_2(), exposes.options.no_occupancy_since_true()],
         convert: (model, msg, publish, options, meta) => {
             if (msg.data.hasOwnProperty('illuminance')) {
                 // The occupancy sensor only sends a message when motion detected.
@@ -3817,7 +3780,7 @@ const converters1 = {
                 // Sometimes RTCGQ14LM reports high illuminance values in the dark
                 // https://github.com/Koenkk/zigbee2mqtt/issues/12596
                 const illuminance = msg.data['illuminance'] > 130536 ? 0 : msg.data['illuminance'] - 65536;
-                const payload = { occupancy: true, illuminance: (0, utils_1.calibrateAndPrecisionRoundOptions)(illuminance, options, 'illuminance') };
+                const payload = { occupancy: true, illuminance };
                 utils.noOccupancySince(msg.endpoint, options, publish, 'start');
                 return payload;
             }
@@ -3924,14 +3887,13 @@ const converters1 = {
     },
     xiaomi_temperature: {
         cluster: 'msTemperatureMeasurement',
-        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature')],
         type: ['attributeReport', 'readResponse'],
         convert: (model, msg, publish, options, meta) => {
             const temperature = parseFloat(msg.data['measuredValue']) / 100.0;
             // https://github.com/Koenkk/zigbee2mqtt/issues/798
             // Sometimes the sensor publishes non-realistic vales.
             if (temperature > -65 && temperature < 65) {
-                return { temperature: (0, utils_1.calibrateAndPrecisionRoundOptions)(temperature, options, 'temperature') };
+                return { temperature };
             }
         },
     },
@@ -4249,10 +4211,9 @@ const converters1 = {
     keen_home_smart_vent_pressure: {
         cluster: 'msPressureMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('pressure'), exposes.options.calibration('pressure')],
         convert: (model, msg, publish, options, meta) => {
             const pressure = msg.data.hasOwnProperty('measuredValue') ? msg.data.measuredValue : parseFloat(msg.data['32']) / 1000.0;
-            return { pressure: (0, utils_1.calibrateAndPrecisionRoundOptions)(pressure, options, 'pressure') };
+            return { pressure };
         },
     },
     U02I007C01_contact: {
@@ -5355,11 +5316,10 @@ const converters1 = {
     schneider_temperature: {
         cluster: 'msTemperatureMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature')],
         convert: (model, msg, publish, options, meta) => {
             const temperature = parseFloat(msg.data['measuredValue']) / 100.0;
             const property = (0, utils_1.postfixWithEndpointName)('local_temperature', msg, model, meta);
-            return { [property]: (0, utils_1.calibrateAndPrecisionRoundOptions)(temperature, options, 'temperature') };
+            return { [property]: temperature };
         },
     },
     wiser_smart_thermostat_client: {
@@ -5668,27 +5628,25 @@ const converters1 = {
     SNZB02_temperature: {
         cluster: 'msTemperatureMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature')],
         convert: (model, msg, publish, options, meta) => {
             const temperature = parseFloat(msg.data['measuredValue']) / 100.0;
             // https://github.com/Koenkk/zigbee2mqtt/issues/13640
             // SNZB-02 reports stranges values sometimes
             if (temperature > -33 && temperature < 100) {
                 const property = (0, utils_1.postfixWithEndpointName)('temperature', msg, model, meta);
-                return { [property]: (0, utils_1.calibrateAndPrecisionRoundOptions)(temperature, options, 'temperature') };
+                return { [property]: temperature };
             }
         },
     },
     SNZB02_humidity: {
         cluster: 'msRelativeHumidity',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('humidity'), exposes.options.calibration('humidity')],
         convert: (model, msg, publish, options, meta) => {
             const humidity = parseFloat(msg.data['measuredValue']) / 100.0;
             // https://github.com/Koenkk/zigbee2mqtt/issues/13640
             // SNZB-02 reports stranges values sometimes
             if (humidity >= 0 && humidity <= 99.75) {
-                return { humidity: (0, utils_1.calibrateAndPrecisionRoundOptions)(humidity, options, 'humidity') };
+                return { humidity };
             }
         },
     },
@@ -6093,7 +6051,6 @@ const converters2 = {
     RTCGQ11LM_illuminance: {
         cluster: 'msIlluminanceMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.calibration('illuminance', 'percentual'), exposes.options.calibration('illuminance_lux', 'percentual')],
         convert: async (model, msg, publish, options, meta) => {
             // also trigger movement, because there is no illuminance without movement
             // https://github.com/Koenkk/zigbee-herdsman-converters/issues/1925
@@ -6102,8 +6059,8 @@ const converters2 = {
             if (payload) {
                 // DEPRECATED: remove illuminance_lux here.
                 const illuminance = msg.data['measuredValue'];
-                payload.illuminance = (0, utils_1.calibrateAndPrecisionRoundOptions)(illuminance, options, 'illuminance');
-                payload.illuminance_lux = (0, utils_1.calibrateAndPrecisionRoundOptions)(illuminance, options, 'illuminance_lux');
+                payload.illuminance = illuminance;
+                payload.illuminance_lux = illuminance;
             }
             return payload;
         },