matterbridge-zigbee2mqtt 2.4.7 → 2.5.0-dev.3

package/CHANGELOG.md

@@ -8,6 +8,42 @@ If you like this project and find it useful, please consider giving it a star on
   <img src="bmc-button.svg" alt="Buy me a coffee" width="120">
 </a>
 
+### Breaking Changes
+
+New device types:
+
+- extendedColorLight
+- waterLeakDetector
+- rainSensor
+- smokeSensor
+
+If your controller has issues detecting the new device type, blacklist these devices, restart, wait 5 minutes, remove the blacklist and restart again. This will create a new endpoint on the controller.
+
+## [2.5.0] - 2025-05-23
+
+### Added
+
+- [scenes]: Added scenes support for groups and devices. See the README.md for explanations.
+- [waterLeak]: Added waterLeakDetector device type for zigbee property "water_leak". Default to false (i.e. no alarm) since is not possible to get the property.
+- [rainSensor]: Added rainSensor device type for zigbee property "rain". Default to false (i.e. no alarm) since is not possible to get the property.
+- [smokeSensor]: Added smokeSensor device type for zigbee property "smoke". Default to false (i.e. no alarm) since is not possible to get the property.
+- [colorTemp]: Added conversion from color temperature to rgb for the rgb devices that don't support color temperature.
+- [battery]: Set batChargeLevel to warning if battery is less than 40% and the device doesn't expose battery_low.
+- [battery]: Set batChargeLevel to critical if battery is less than 20% and the device doesn't expose battery_low.
+- [retain]: Send retained mqtt states at startup if z2m has retain enabled.
+
+### Changed
+
+- [package]: Updated package.
+- [package]: Updated dependencies.
+- [plugin]: Requires Matterbridge 3.0.3.
+- [config]: As anticipated in the previous release, the parameter postfixHostname has been removed. Use postfix if needed.
+- [colorRgb]: Changed the default device type from colorTemperatureLight to extendedColorLight to solve the SmartThings issue with colors.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [2.4.7] - 2025-03-19
 
 ### Added

package/README.md

@@ -17,7 +17,7 @@ Matterbridge zigbee2mqtt is a matterbridge production-level plugin that expose a
 
 No hub or dedicated hardware needed.
 
-Interested in super fast and autonomous automations for zigbee2mqtt? Try this: https://github.com/Luligu/zigbee2mqtt-automations
+Interested in super fast and autonomous **[automations for zigbee2mqtt](https://github.com/Luligu/zigbee2mqtt-automations)**? Try this: https://github.com/Luligu/zigbee2mqtt-automations.
 
 If you like this project and find it useful, please consider giving it a star on GitHub at https://github.com/Luligu/matterbridge-zigbee2mqtt and sponsoring it.
 
@@ -150,8 +150,9 @@ These are the default vules:
   "outletList": [],
   "featureBlackList": [],
   "deviceFeatureBlackList": {},
-  "postfix": "",
-  "postfixHostname": true
+  "scenesType": "outlet",
+  "scenesPrefix: true,
+  "postfix": ""
 }
 ```
 
@@ -223,6 +224,14 @@ The latest release also supports all clusters in the multi endpoints devices (e.
 
 Since the Matter support in the available ecosystems (controllers) is sometimes limited and, when available, only covers Matter 1.1 specifications, some z2m devices cannot be exposed properly or cannot be exposed at all.
 
+## Availability
+
+If the availability is enabled in zigbee2mqtt settings, it is exposed.
+
+## Retain
+
+If the retain option is enabled in zigbee2mqtt settings or device setting, at restart all retained states are updated.
+
 ## Unsupported devices
 
 If one of your devices is not supported out of the box, open an issue and we will try to support it if possible.
@@ -250,6 +259,20 @@ If one of your devices is not supported out of the box, open an issue and we wil
 
 ![See the screenshot here](https://github.com/Luligu/matterbridge-zigbee2mqtt/blob/main/screenshot/Smart%20button.png)
 
+## Scenes in groups and devices
+
+With release 2.5.0 has been added support for scenes in groups and devices.
+
+In the config select what device type you want to use to expose the command that runs the scene: 'light' | 'outlet' | 'switch' | 'mounted_switch'.
+
+Switch is not supported by Alexa. Mounted Switch is not supported by Apple Home.
+
+The virtual device takes the name of the group or device it belongs to, with added the name of scene. If scenesPrefix is disabled, it takes only the name of the scene. Consider that in Matter the node name is 32 characters long.
+
+The state of the virtual device is always reverted to off in a few seconds.
+
+It is possibile to disable the feature globally with featureBlackList and on a per device/group base with deviceFeatureBlackList.
+
 # Known issues
 
 For general controller issues check the Matterbridge Known issues section

package/dist/entity.js

@@ -1,12 +1,11 @@
-import { airQualitySensor, colorTemperatureSwitch, dimmableSwitch, onOffSwitch, powerSource, bridgedNode, electricalSensor, onOffLight, dimmableLight, colorTemperatureLight, onOffOutlet, coverDevice, thermostatDevice, MatterbridgeEndpoint, dimmableOutlet, doorLockDevice, occupancySensor, lightSensor, contactSensor, temperatureSensor, humiditySensor, pressureSensor, genericSwitch, } from 'matterbridge';
+import { airQualitySensor, colorTemperatureSwitch, dimmableSwitch, onOffSwitch, powerSource, bridgedNode, electricalSensor, onOffLight, dimmableLight, colorTemperatureLight, onOffOutlet, coverDevice, thermostatDevice, MatterbridgeEndpoint, dimmableOutlet, doorLockDevice, occupancySensor, lightSensor, contactSensor, temperatureSensor, humiditySensor, pressureSensor, genericSwitch, waterLeakDetector, rainSensor, smokeCoAlarm, extendedColorLight, } from 'matterbridge';
 import { AnsiLogger, gn, dn, ign, idn, rs, db, debugStringify, hk, zb, or, nf, CYAN, er, YELLOW } from 'matterbridge/logger';
-import { deepCopy, deepEqual, isValidNumber } from 'matterbridge/utils';
+import { deepCopy, deepEqual, isValidNumber, kelvinToRGB, miredToKelvin } from 'matterbridge/utils';
 import * as color from 'matterbridge/utils';
 import { SwitchesTag, NumberTag } from 'matterbridge/matter';
 import { getClusterNameById, ClusterId } from 'matterbridge/matter/types';
-import { ElectricalEnergyMeasurement, ElectricalPowerMeasurement, OnOffCluster, LevelControlCluster, WindowCoveringCluster, DoorLockCluster, BridgedDeviceBasicInformation, OnOff, LevelControl, ColorControl, ColorControlCluster, TemperatureMeasurement, BooleanState, RelativeHumidityMeasurement, PressureMeasurement, OccupancySensing, IlluminanceMeasurement, PowerSource, WindowCovering, DoorLock, ThermostatCluster, Thermostat, AirQuality, TotalVolatileOrganicCompoundsConcentrationMeasurement, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FormaldehydeConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, Pm10ConcentrationMeasurement, } from 'matterbridge/matter/clusters';
+import { ElectricalEnergyMeasurement, ElectricalPowerMeasurement, OnOffCluster, LevelControlCluster, WindowCoveringCluster, DoorLockCluster, BridgedDeviceBasicInformation, OnOff, LevelControl, ColorControl, ColorControlCluster, TemperatureMeasurement, BooleanState, RelativeHumidityMeasurement, PressureMeasurement, OccupancySensing, IlluminanceMeasurement, PowerSource, WindowCovering, DoorLock, ThermostatCluster, Thermostat, AirQuality, TotalVolatileOrganicCompoundsConcentrationMeasurement, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FormaldehydeConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, Pm10ConcentrationMeasurement, SmokeCoAlarm, } from 'matterbridge/matter/clusters';
 import EventEmitter from 'node:events';
-import { hostname } from 'node:os';
 export class ZigbeeEntity extends EventEmitter {
     log;
     serial = '';
@@ -87,6 +86,17 @@ export class ZigbeeEntity extends EventEmitter {
                     return;
                 if (key === 'voltage' && this.isDevice && this.device?.power_source === 'Battery')
                     key = 'battery_voltage';
+                if (key === 'battery' && !('battery_low' in payload) && isValidNumber(value, 0, 100) && this.isDevice && this.device?.power_source === 'Battery') {
+                    if (value < 20) {
+                        this.updateAttributeIfChanged(this.bridgedDevice, undefined, PowerSource.Cluster.id, 'batChargeLevel', PowerSource.BatChargeLevel.Critical);
+                    }
+                    else if (value < 40) {
+                        this.updateAttributeIfChanged(this.bridgedDevice, undefined, PowerSource.Cluster.id, 'batChargeLevel', PowerSource.BatChargeLevel.Warning);
+                    }
+                    else {
+                        this.updateAttributeIfChanged(this.bridgedDevice, undefined, PowerSource.Cluster.id, 'batChargeLevel', PowerSource.BatChargeLevel.Ok);
+                    }
+                }
                 const propertyMap = this.propertyMap.get(key);
                 if (propertyMap) {
                     this.log.debug(`Payload entry ${CYAN}${key}${db} => name: ${CYAN}${propertyMap.name}${db} type: ${CYAN}${propertyMap.type === '' ? 'generic' : propertyMap.type}${db} ` +
@@ -110,7 +120,7 @@ export class ZigbeeEntity extends EventEmitter {
                     const propertyMap = this.propertyMap.get(('action_' + value));
                     if (propertyMap) {
                         const child = this.bridgedDevice.getChildEndpointByName(propertyMap.endpoint);
-                        if (child && child.number)
+                        if (child && child.maybeNumber)
                             child.triggerSwitchEvent(propertyMap.action, this.log);
                     }
                     else
@@ -294,11 +304,11 @@ export class ZigbeeEntity extends EventEmitter {
         }
         const localValue = deviceEndpoint.getAttribute(ClusterId(clusterId), attributeName, undefined);
         if (typeof value === 'object' ? deepEqual(value, localValue) : value === localValue) {
-            this.log.debug(`Skip update endpoint ${deviceEndpoint.name}:${deviceEndpoint.number}${childEndpointName ? ' (' + childEndpointName + ')' : ''} ` +
+            this.log.debug(`Skip update endpoint ${deviceEndpoint.name}:${deviceEndpoint.maybeNumber}${childEndpointName ? ' (' + childEndpointName + ')' : ''} ` +
                 `attribute ${getClusterNameById(ClusterId(clusterId))}.${attributeName} already ${typeof value === 'object' ? debugStringify(value) : value}`);
             return;
         }
-        this.log.info(`${db}Update endpoint ${this.eidn}${deviceEndpoint.name}:${deviceEndpoint.number}${db}${childEndpointName ? ' (' + zb + childEndpointName + db + ')' : ''} ` +
+        this.log.info(`${db}Update endpoint ${this.eidn}${deviceEndpoint.name}:${deviceEndpoint.maybeNumber}${db}${childEndpointName ? ' (' + zb + childEndpointName + db + ')' : ''} ` +
             `attribute ${hk}${getClusterNameById(ClusterId(clusterId))}${db}.${hk}${attributeName}${db} from ${YELLOW}${typeof localValue === 'object' ? debugStringify(localValue) : localValue}${db} to ${YELLOW}${typeof value === 'object' ? debugStringify(value) : value}${db}`);
         try {
             deviceEndpoint.setAttribute(ClusterId(clusterId), attributeName, value);
@@ -330,10 +340,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
     }
     static async create(platform, group) {
         const zigbeeGroup = new ZigbeeGroup(platform, group);
-        if (zigbeeGroup.platform.postfixHostname) {
-            zigbeeGroup.serial = `group-${group.id}_${hostname}`.slice(0, 32);
-        }
-        else if (zigbeeGroup.platform.postfix !== '') {
+        if (zigbeeGroup.platform.postfix !== '') {
             zigbeeGroup.serial = `group-${group.id}-${zigbeeGroup.platform.postfix}`.slice(0, 32);
         }
         else {
@@ -419,7 +426,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
                 zigbeeGroup.propertyMap.set('color_temp', { name: 'color_temp', type: 'light', endpoint: '' });
             }
             if (useColor) {
-                deviceType = colorTemperatureLight;
+                deviceType = extendedColorLight;
                 zigbeeGroup.propertyMap.set('color', { name: 'color', type: 'light', endpoint: '' });
             }
             if (isCover) {
@@ -440,9 +447,14 @@ export class ZigbeeGroup extends ZigbeeEntity {
                 return zigbeeGroup;
             zigbeeGroup.bridgedDevice = new MatterbridgeEndpoint([deviceType, bridgedNode, powerSource], { uniqueStorageKey: group.friendly_name }, zigbeeGroup.log.logLevel === "debug");
         }
-        if (platform.config.groupScenes === true) {
+        if (!platform.featureBlackList?.includes('scenes') && !platform.deviceFeatureBlackList[group.friendly_name]?.includes('scenes')) {
             group.scenes.forEach((scene) => {
                 zigbeeGroup.log.debug(`***Group ${gn}${group.friendly_name}${rs}${db} scene ${CYAN}${scene.name}${db} id ${CYAN}${scene.id}${db}`);
+                platform.setSelectDeviceEntity(`group-${group.id}`, 'scenes', 'Scenes', 'component');
+                platform.registerVirtualDevice(`${platform.config.scenesPrefix ? group.friendly_name + ' ' : ''}${scene.name}`, async () => {
+                    zigbeeGroup.log.info(`Triggered scene "${scene.name}" id ${scene.id} from group ${group.friendly_name}`);
+                    zigbeeGroup.publishCommand('scene_recall', group.friendly_name, { 'scene_recall': scene.id });
+                });
             });
         }
         zigbeeGroup.addBridgedDeviceBasicInformation();
@@ -458,7 +470,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
             if (isLight)
                 await zigbeeGroup.bridgedDevice.addFixedLabel('type', 'light');
             zigbeeGroup.bridgedDevice.addCommandHandler('identify', async ({ request: { identifyTime } }) => {
-                zigbeeGroup.log.warn(`Command identify called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} identifyTime:${identifyTime}`);
+                zigbeeGroup.log.debug(`Command identify called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} identifyTime:${identifyTime}`);
             });
             zigbeeGroup.bridgedDevice.addCommandHandler('on', async () => {
                 zigbeeGroup.log.debug(`Command on called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db}`);
@@ -520,6 +532,14 @@ export class ZigbeeGroup extends ZigbeeEntity {
                     const rgb = color.hslColorToRgbColor((request.hue / 254) * 360, (request.saturation / 254) * 100, 50);
                     zigbeeGroup.publishCommand('moveToHueAndSaturation', group.friendly_name, { color: { r: rgb.r, g: rgb.g, b: rgb.b } });
                 });
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToColor', async ({ request }) => {
+                    zigbeeGroup.log.debug(`Command moveToColor called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: X: ${request.colorX} Y: ${request.colorY}`);
+                    await zigbeeGroup.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentXAndCurrentY, zigbeeGroup.log);
+                    const payload = { color: { x: request.colorX / 65536, y: request.colorY / 65536 } };
+                    if (zigbeeGroup.transition && request.transitionTime && request.transitionTime / 10 >= 1)
+                        payload['transition'] = Math.round(request.transitionTime / 10);
+                    zigbeeGroup.publishCommand('moveToColor', group.friendly_name, payload);
+                });
             }
         }
         if (isCover) {
@@ -600,8 +620,8 @@ export const z2ms = [
     { type: 'outlet', name: 'brightness', property: 'brightness', deviceType: dimmableOutlet, cluster: LevelControl.Cluster.id, attribute: 'currentLevel', converter: (value) => { return Math.max(1, Math.min(254, value)); } },
     { type: 'light', name: 'state', property: 'state', deviceType: onOffLight, cluster: OnOff.Cluster.id, attribute: 'onOff', converter: (value) => { return value === 'ON' ? true : false; } },
     { type: 'light', name: 'brightness', property: 'brightness', deviceType: dimmableLight, cluster: LevelControl.Cluster.id, attribute: 'currentLevel', converter: (value) => { return Math.max(1, Math.min(254, value)); } },
-    { type: 'light', name: 'color_hs', property: 'color_hs', deviceType: colorTemperatureLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
-    { type: 'light', name: 'color_xy', property: 'color_xy', deviceType: colorTemperatureLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
+    { type: 'light', name: 'color_hs', property: 'color_hs', deviceType: extendedColorLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
+    { type: 'light', name: 'color_xy', property: 'color_xy', deviceType: extendedColorLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
     { type: 'light', name: 'color_temp', property: 'color_temp', deviceType: colorTemperatureLight, cluster: ColorControl.Cluster.id, attribute: 'colorMode' },
     { type: 'cover', name: 'state', property: 'state', deviceType: coverDevice, cluster: WindowCovering.Cluster.id, attribute: 'targetPositionLiftPercent100ths' },
     { type: 'cover', name: 'moving', property: 'moving', deviceType: coverDevice, cluster: WindowCovering.Cluster.id, attribute: 'operationalStatus' },
@@ -623,9 +643,10 @@ export const z2ms = [
     { type: '', name: 'occupancy', property: 'occupancy', deviceType: occupancySensor, cluster: OccupancySensing.Cluster.id, attribute: 'occupancy', converter: (value) => { return { occupied: value }; } },
     { type: '', name: 'illuminance', property: 'illuminance', deviceType: lightSensor, cluster: IlluminanceMeasurement.Cluster.id, attribute: 'measuredValue', converter: (value) => { return Math.round(Math.max(Math.min(10000 * Math.log10(value), 0xfffe), 0)); } },
     { type: '', name: 'contact', property: 'contact', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return value; } },
-    { type: '', name: 'water_leak', property: 'water_leak', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return !value; } },
+    { type: '', name: 'water_leak', property: 'water_leak', deviceType: waterLeakDetector, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return value; } },
+    { type: '', name: 'rain', property: 'rain', deviceType: rainSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return value; } },
     { type: '', name: 'vibration', property: 'vibration', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return !value; } },
-    { type: '', name: 'smoke', property: 'smoke', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return !value; } },
+    { type: '', name: 'smoke', property: 'smoke', deviceType: smokeCoAlarm, cluster: SmokeCoAlarm.Cluster.id, attribute: 'smokeState', converter: (value) => { return value ? SmokeCoAlarm.AlarmState.Critical : SmokeCoAlarm.AlarmState.Normal; } },
     { type: '', name: 'carbon_monoxide', property: 'carbon_monoxide', deviceType: contactSensor, cluster: BooleanState.Cluster.id, attribute: 'stateValue', converter: (value) => { return !value; } },
     { type: '', name: 'temperature', property: 'temperature', deviceType: temperatureSensor, cluster: TemperatureMeasurement.Cluster.id, attribute: 'measuredValue', converter: (value) => { return Math.round(value * 100); } },
     { type: '', name: 'humidity', property: 'humidity', deviceType: humiditySensor, cluster: RelativeHumidityMeasurement.Cluster.id, attribute: 'measuredValue', converter: (value) => { return Math.round(value * 100); } },
@@ -644,10 +665,10 @@ export const z2ms = [
     { type: '', name: '', property: 'battery', deviceType: powerSource, cluster: PowerSource.Cluster.id, attribute: 'batPercentRemaining', converter: (value) => { return Math.round(value * 2); } },
     { type: '', name: '', property: 'battery_low', deviceType: powerSource, cluster: PowerSource.Cluster.id, attribute: 'batChargeLevel', converter: (value) => { return value === true ? PowerSource.BatChargeLevel.Critical : PowerSource.BatChargeLevel.Ok; } },
     { type: '', name: '', property: 'battery_voltage', deviceType: powerSource, cluster: PowerSource.Cluster.id, attribute: 'batVoltage', converter: (value) => { return value; } },
-    { type: '', name: 'energy', property: 'energy', deviceType: electricalSensor, cluster: ElectricalEnergyMeasurement.Cluster.id, attribute: 'cumulativeEnergyImported', converter: (value) => { return { energy: value * 1000000 }; } },
-    { type: '', name: 'power', property: 'power', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'activePower', converter: (value) => { return value * 1000; } },
-    { type: '', name: 'voltage', property: 'voltage', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'voltage', converter: (value) => { return value * 1000; } },
-    { type: '', name: 'current', property: 'current', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'activeCurrent', converter: (value) => { return value * 1000; } },
+    { type: '', name: 'energy', property: 'energy', deviceType: electricalSensor, cluster: ElectricalEnergyMeasurement.Cluster.id, attribute: 'cumulativeEnergyImported', converter: (value) => { return { energy: Math.round(value * 1000000) }; } },
+    { type: '', name: 'power', property: 'power', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'activePower', converter: (value) => { return Math.round(value * 1000); } },
+    { type: '', name: 'voltage', property: 'voltage', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'voltage', converter: (value) => { return Math.round(value * 1000); } },
+    { type: '', name: 'current', property: 'current', deviceType: electricalSensor, cluster: ElectricalPowerMeasurement.Cluster.id, attribute: 'activeCurrent', converter: (value) => { return Math.round(value * 1000); } },
 ];
 export class ZigbeeDevice extends ZigbeeEntity {
     constructor(platform, device) {
@@ -656,37 +677,42 @@ export class ZigbeeDevice extends ZigbeeEntity {
     static async create(platform, device) {
         const zigbeeDevice = new ZigbeeDevice(platform, device);
         zigbeeDevice.serial = `${device.ieee_address}`;
-        if (zigbeeDevice.platform.postfixHostname) {
-            zigbeeDevice.serial = `${zigbeeDevice.serial}_${hostname}`.slice(0, 32);
-        }
-        else if (zigbeeDevice.platform.postfix !== '') {
+        if (zigbeeDevice.platform.postfix !== '') {
             zigbeeDevice.serial = `${zigbeeDevice.serial}-${zigbeeDevice.platform.postfix}`.slice(0, 32);
         }
         if (device.friendly_name === 'Coordinator' || (device.model_id === 'ti.router' && device.manufacturer === 'TexasInstruments') || (device.model_id.startsWith('SLZB-') && device.manufacturer === 'SMLIGHT')) {
             zigbeeDevice.isRouter = true;
             platform.setSelectDevice(device.ieee_address, device.friendly_name, 'wifi');
-            zigbeeDevice.bridgedDevice = new MatterbridgeEndpoint([doorLockDevice], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
+            zigbeeDevice.bridgedDevice = new MatterbridgeEndpoint([doorLockDevice, bridgedNode, powerSource], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
             zigbeeDevice.addBridgedDeviceBasicInformation();
             zigbeeDevice.addPowerSource();
             zigbeeDevice.bridgedDevice.addRequiredClusterServers();
             await zigbeeDevice.bridgedDevice.addFixedLabel('type', 'lock');
             zigbeeDevice.verifyMutableDevice(zigbeeDevice.bridgedDevice);
+            zigbeeDevice.bridgedDevice.addCommandHandler('identify', async (data) => {
+                zigbeeDevice.log.debug(`Command identify called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request identifyTime:${data.request.identifyTime} `);
+            });
             zigbeeDevice.bridgedDevice.addCommandHandler('lockDoor', async () => {
-                zigbeeDevice.log.debug(`Command permit_join: false called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
+                zigbeeDevice.log.debug(`Command permit_join false called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(DoorLockCluster.id, 'lockState', DoorLock.LockState.Locked, zigbeeDevice.log);
-                zigbeeDevice.publishCommand('permit_join: false', 'bridge/request/permit_join', { value: false });
+                zigbeeDevice.publishCommand('permit_join false', 'bridge/request/permit_join', { value: false });
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('unlockDoor', async () => {
-                zigbeeDevice.log.debug(`Command permit_join: true called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
+                zigbeeDevice.log.debug(`Command permit_join true called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(DoorLockCluster.id, 'lockState', DoorLock.LockState.Unlocked, zigbeeDevice.log);
-                zigbeeDevice.publishCommand('permit_join: true', 'bridge/request/permit_join', { value: true });
+                zigbeeDevice.publishCommand('permit_join true', 'bridge/request/permit_join', { value: true });
             });
             return zigbeeDevice;
         }
-        if (platform.config.deviceScenes === true) {
+        if (!platform.featureBlackList?.includes('scenes') && !platform.deviceFeatureBlackList[device.friendly_name]?.includes('scenes')) {
             Object.entries(device.endpoints).forEach(([key, endpoint]) => {
                 Object.values(endpoint.scenes).forEach((scene) => {
                     zigbeeDevice.log.debug(`***Device ${dn}${device.friendly_name}${rs}${db} endpoint ${CYAN}${key}${db} scene ${CYAN}${scene.name}${db} id ${CYAN}${scene.id}${db}`);
+                    platform.setSelectDeviceEntity(device.ieee_address, 'scenes', 'Scenes', 'component');
+                    platform.registerVirtualDevice(`${platform.config.scenesPrefix ? device.friendly_name + ' ' : ''}${scene.name}`, async () => {
+                        zigbeeDevice.log.info(`Triggered scene "${scene.name}" id ${scene.id} from device ${device.friendly_name}`);
+                        zigbeeDevice.publishCommand('scene_recall', device.friendly_name, { 'scene_recall': scene.id });
+                    });
                 });
             });
         }
@@ -908,6 +934,11 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 deviceTypesMap.delete(onOffLight.code);
             if (deviceTypesMap.has(dimmableLight.code) && deviceTypesMap.has(colorTemperatureLight.code))
                 deviceTypesMap.delete(dimmableLight.code);
+            if (deviceTypesMap.has(dimmableLight.code) && deviceTypesMap.has(extendedColorLight.code))
+                deviceTypesMap.delete(dimmableLight.code);
+            if (deviceTypesMap.has(colorTemperatureLight.code) && deviceTypesMap.has(extendedColorLight.code))
+                deviceTypesMap.delete(colorTemperatureLight.code);
+            deviceTypesMap.delete(bridgedNode.code);
             deviceTypesMap.delete(powerSource.code);
             device.deviceTypes = Array.from(deviceTypesMap.values());
         }
@@ -943,12 +974,26 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${zigbeeDevice.device?.friendly_name}${rs}${db} endpoint: ${ign}${endpoint === '' ? 'main' : endpoint}${rs}${db} => ` +
                 `${nf}tagList: ${debugStringify(device.tagList)} deviceTypes: ${debugStringify(device.deviceTypes)} clusterServersIds: ${debugStringify(device.clusterServersIds)}`);
         }
+        if ((mainEndpoint.deviceTypes.find((dt) => dt.code === waterLeakDetector.code) || mainEndpoint.deviceTypes.find((dt) => dt.code === rainSensor.code)) && mainEndpoint.clusterServersIds.includes(BooleanState.Cluster.id)) {
+            zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} BooleanStateCluster cluster with`);
+            zigbeeDevice.bridgedDevice.createDefaultBooleanStateClusterServer(false);
+            mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(BooleanState.Cluster.id), 1);
+        }
+        if (mainEndpoint.deviceTypes.find((dt) => dt.code === smokeCoAlarm.code) && mainEndpoint.clusterServersIds.includes(SmokeCoAlarm.Cluster.id)) {
+            zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} SmokeCoAlarmCluster cluster with`);
+            zigbeeDevice.bridgedDevice.createSmokeOnlySmokeCOAlarmClusterServer(SmokeCoAlarm.AlarmState.Normal);
+            mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(SmokeCoAlarm.Cluster.id), 1);
+        }
         if (mainEndpoint.clusterServersIds.includes(ColorControl.Cluster.id)) {
-            zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} ColorControlCluster cluster with HS: ${names.includes('color_hs')} XY: ${names.includes('color_xy')} CT: ${names.includes('color_temp')}`);
             if (!names.includes('color_hs') && !names.includes('color_xy')) {
-                zigbeeDevice.bridgedDevice.createCtColorControlClusterServer();
-                mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(ColorControl.Cluster.id), 1);
+                zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} ColorControlCluster cluster with CT: ${names.includes('color_temp')} min: ${zigbeeDevice.propertyMap.get('color_temp')?.value_min} max: ${zigbeeDevice.propertyMap.get('color_temp')?.value_max}`);
+                zigbeeDevice.bridgedDevice.createCtColorControlClusterServer(zigbeeDevice.propertyMap.get('color_temp')?.value_max, zigbeeDevice.propertyMap.get('color_temp')?.value_min, zigbeeDevice.propertyMap.get('color_temp')?.value_max);
             }
+            else {
+                zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} ColorControlCluster cluster with HS: ${names.includes('color_hs')} XY: ${names.includes('color_xy')} CT: ${names.includes('color_temp')} min: ${zigbeeDevice.propertyMap.get('color_temp')?.value_min} max: ${zigbeeDevice.propertyMap.get('color_temp')?.value_max}`);
+                zigbeeDevice.bridgedDevice.createDefaultColorControlClusterServer(undefined, undefined, undefined, undefined, zigbeeDevice.propertyMap.get('color_temp')?.value_max, zigbeeDevice.propertyMap.get('color_temp')?.value_min, zigbeeDevice.propertyMap.get('color_temp')?.value_max);
+            }
+            mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(ColorControl.Cluster.id), 1);
         }
         if (mainEndpoint.clusterServersIds.includes(Thermostat.Cluster.id)) {
             const system_mode = zigbeeDevice.propertyMap.get('system_mode');
@@ -991,25 +1036,25 @@ export class ZigbeeDevice extends ZigbeeEntity {
         zigbeeDevice.mutableDevice.clear();
         zigbeeDevice.logPropertyMap();
         zigbeeDevice.bridgedDevice.addCommandHandler('identify', async (data) => {
-            zigbeeDevice.log.debug(`Command identify called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request identifyTime:${data.request.identifyTime} `);
+            zigbeeDevice.log.debug(`Command identify called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request identifyTime:${data.request.identifyTime} `);
         });
         if (zigbeeDevice.bridgedDevice.hasClusterServer(OnOffCluster.id) || zigbeeDevice.hasEndpoints) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
                 if (child.hasClusterServer(OnOffCluster)) {
                     child.addCommandHandler('on', async (data) => {
-                        zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
+                        zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
                         const payload = {};
                         payload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
                         zigbeeDevice.publishCommand('on', device.friendly_name, payload);
                     });
                     child.addCommandHandler('off', async (data) => {
-                        zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
+                        zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
                         const payload = {};
                         payload['state_' + data.endpoint.uniqueStorageKey] = 'OFF';
                         zigbeeDevice.publishCommand('off', device.friendly_name, payload);
                     });
                     child.addCommandHandler('toggle', async (data) => {
-                        zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
+                        zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
                         const payload = {};
                         payload['state_' + data.endpoint.uniqueStorageKey] = 'TOGGLE';
                         zigbeeDevice.publishCommand('toggle', device.friendly_name, payload);
@@ -1017,41 +1062,23 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 }
             }
             zigbeeDevice.bridgedDevice.addCommandHandler('on', async (data) => {
-                zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['state'] = 'ON';
-                else
-                    payload['state_' + label] = 'ON';
-                zigbeeDevice.publishCommand('on', device.friendly_name, payload);
+                zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
+                zigbeeDevice.publishCommand('on', device.friendly_name, { state: 'ON' });
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('off', async (data) => {
-                zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['state'] = 'OFF';
-                else
-                    payload['state_' + label] = 'OFF';
-                zigbeeDevice.publishCommand('off', device.friendly_name, payload);
+                zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
+                zigbeeDevice.publishCommand('off', device.friendly_name, { state: 'OFF' });
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('toggle', async (data) => {
-                zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['state'] = 'TOGGLE';
-                else
-                    payload['state_' + label] = 'TOGGLE';
-                zigbeeDevice.publishCommand('toggle', device.friendly_name, payload);
+                zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
+                zigbeeDevice.publishCommand('toggle', device.friendly_name, { state: 'TOGGLE' });
             });
         }
         if (zigbeeDevice.bridgedDevice.hasClusterServer(LevelControlCluster.id) || zigbeeDevice.hasEndpoints) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
                 if (child.hasClusterServer(LevelControlCluster)) {
                     child.addCommandHandler('moveToLevel', async (data) => {
-                        zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                        zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
                         const payload = {};
                         payload['brightness_' + data.endpoint.uniqueStorageKey] = data.request.level;
                         if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
@@ -1059,7 +1086,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                         zigbeeDevice.publishCommand('moveToLevel', device.friendly_name, payload);
                     });
                     child.addCommandHandler('moveToLevelWithOnOff', async (data) => {
-                        zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                        zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
                         const payload = {};
                         payload['brightness_' + data.endpoint.uniqueStorageKey] = data.request.level;
                         if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
@@ -1069,25 +1096,15 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 }
             }
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToLevel', async (data) => {
-                zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request: ${data.request.level} transition: ${data.request.transitionTime}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['brightness'] = data.request.level;
-                else
-                    payload['brightness_' + label] = data.request.level;
+                zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                const payload = { brightness: data.request.level };
                 if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
                     payload['transition'] = Math.round(data.request.transitionTime / 10);
                 zigbeeDevice.publishCommand('moveToLevel', device.friendly_name, payload);
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToLevelWithOnOff', async (data) => {
-                zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint.number} request: ${data.request.level} transition: ${data.request.transitionTime}`);
-                const payload = {};
-                const label = zigbeeDevice.platform.matterbridge.edge ? undefined : data.endpoint.uniqueStorageKey;
-                if (label === undefined)
-                    payload['brightness'] = data.request.level;
-                else
-                    payload['brightness_' + label] = data.request.level;
+                zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                const payload = { brightness: data.request.level };
                 if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
                     payload['transition'] = Math.round(data.request.transitionTime / 10);
                 zigbeeDevice.publishCommand('moveToLevelWithOnOff', device.friendly_name, payload);
@@ -1097,7 +1114,15 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToColorTemperature', async ({ request }) => {
                 zigbeeDevice.log.debug(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request: ${request.colorTemperatureMireds}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds, zigbeeDevice.log);
-                const payload = { color_temp: request.colorTemperatureMireds };
+                const payload = {};
+                if (zigbeeDevice.propertyMap.get('color_temp')) {
+                    payload['color_temp'] = request.colorTemperatureMireds;
+                }
+                else {
+                    const rgb = kelvinToRGB(miredToKelvin(request.colorTemperatureMireds));
+                    payload['color'] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                    zigbeeDevice.log.info(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${nf} but color_temp property is not available. Converting ${request.colorTemperatureMireds} to RGB ${debugStringify(payload['color'])}.`);
+                }
                 if (zigbeeDevice.transition && request.transitionTime && request.transitionTime / 10 >= 1)
                     payload['transition'] = Math.round(request.transitionTime / 10);
                 zigbeeDevice.publishCommand('moveToColorTemperature', device.friendly_name, payload);
@@ -1156,7 +1181,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.bridgedDevice.addCommandHandler('upOrOpen', async () => {
                 zigbeeDevice.log.debug(`Command upOrOpen called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
                 if (zigbeeDevice.isDevice && zigbeeDevice.propertyMap.has('position'))
-                    zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', 0, zigbeeDevice.log);
+                    await zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', 0, zigbeeDevice.log);
                 else
                     await zigbeeDevice.bridgedDevice?.setWindowCoveringTargetAndCurrentPosition(0);
                 zigbeeDevice.publishCommand('upOrOpen', device.friendly_name, { state: 'OPEN' });
@@ -1164,7 +1189,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.bridgedDevice.addCommandHandler('downOrClose', async () => {
                 zigbeeDevice.log.debug(`Command downOrClose called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`);
                 if (zigbeeDevice.isDevice && zigbeeDevice.propertyMap.has('position'))
-                    zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', 10000, zigbeeDevice.log);
+                    await zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', 10000, zigbeeDevice.log);
                 else
                     await zigbeeDevice.bridgedDevice?.setWindowCoveringTargetAndCurrentPosition(10000);
                 zigbeeDevice.publishCommand('downOrClose', device.friendly_name, { state: 'CLOSE' });
@@ -1177,7 +1202,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.bridgedDevice.addCommandHandler('goToLiftPercentage', async ({ request: { liftPercent100thsValue } }) => {
                 zigbeeDevice.log.debug(`Command goToLiftPercentage called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request liftPercent100thsValue: ${liftPercent100thsValue}`);
                 if (zigbeeDevice.isDevice && zigbeeDevice.propertyMap.has('position'))
-                    zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', liftPercent100thsValue, zigbeeDevice.log);
+                    await zigbeeDevice.bridgedDevice?.setAttribute(WindowCoveringCluster.id, 'targetPositionLiftPercent100ths', liftPercent100thsValue, zigbeeDevice.log);
                 else
                     await zigbeeDevice.bridgedDevice?.setWindowCoveringTargetAndCurrentPosition(liftPercent100thsValue);
                 zigbeeDevice.publishCommand('goToLiftPercentage', device.friendly_name, { position: liftPercent100thsValue / 100 });
@@ -1202,7 +1227,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     const t = zigbeeDevice.bridgedDevice?.getAttribute(ThermostatCluster.id, 'occupiedHeatingSetpoint', zigbeeDevice.log);
                     const setpoint = Math.round(t / 100 + request.amount / 10);
                     if (zigbeeDevice.propertyMap.has('current_heating_setpoint')) {
-                        zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
+                        zigbeeDevice.publishCommand('CurrentHeatingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
                     }
                     else if (zigbeeDevice.propertyMap.has('occupied_heating_setpoint')) {
                         zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { occupied_heating_setpoint: setpoint });
@@ -1212,7 +1237,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     const t = zigbeeDevice.bridgedDevice?.getAttribute(ThermostatCluster.id, 'occupiedCoolingSetpoint', zigbeeDevice.log);
                     const setpoint = Math.round(t / 100 + request.amount / 10);
                     if (zigbeeDevice.propertyMap.has('current_heating_setpoint')) {
-                        zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
+                        zigbeeDevice.publishCommand('CurrentCoolingSetpoint', device.friendly_name, { current_heating_setpoint: setpoint });
                     }
                     else if (zigbeeDevice.propertyMap.has('occupied_cooling_setpoint')) {
                         zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { occupied_cooling_setpoint: setpoint });

package/dist/platform.js

@@ -1,4 +1,4 @@
-import { MatterbridgeDynamicPlatform } from 'matterbridge';
+import { addVirtualDevice, MatterbridgeDynamicPlatform } from 'matterbridge';
 import { dn, gn, db, wr, zb, payloadStringify, rs, debugStringify, CYAN, er, nf } from 'matterbridge/logger';
 import { isValidNumber, isValidString, waiter } from 'matterbridge/utils';
 import { BridgedDeviceBasicInformation, DoorLock } from 'matterbridge/matter/clusters';
@@ -11,6 +11,7 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     bridgedDevices = [];
     zigbeeEntities = [];
     injectTimer;
+    namePostfix = 1;
     mqttHost = 'localhost';
     mqttPort = 1883;
     mqttTopic = 'zigbee2mqtt';
@@ -23,7 +24,6 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     featureBlackList = [];
     deviceFeatureBlackList = {};
     postfix = '';
-    postfixHostname = true;
     debugEnabled;
     shouldStart;
     shouldConfigure;
@@ -34,12 +34,13 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     z2mBridgeInfo;
     z2mBridgeDevices;
     z2mBridgeGroups;
-    z2mDeviceAvailability = new Map();
+    z2mEntityAvailability = new Map();
+    z2mEntityPayload = new Map();
     availabilityTimer;
     constructor(matterbridge, log, config) {
         super(matterbridge, log, config);
-        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('2.2.5')) {
-            throw new Error(`This plugin requires Matterbridge version >= "2.2.5". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend."`);
+        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.0.3')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.0.3". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend."`);
         }
         this.debugEnabled = config.debug;
         this.shouldStart = false;
@@ -69,7 +70,6 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         if (config.postfix)
             this.postfix = config.postfix;
         this.postfix = this.postfix.trim().slice(0, 3);
-        this.postfixHostname = config.postfixHostname ?? true;
         config.host = this.mqttHost;
         config.port = this.mqttPort;
         config.protocolVersion = this.mqttProtocol;
@@ -77,7 +77,16 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         config.username = this.mqttUsername;
         config.password = this.mqttPassword;
         config.postfix = this.postfix;
-        config.postfixHostname = this.postfixHostname;
+        if (config.postfixHostname !== undefined)
+            delete config.postfixHostname;
+        if (config.deviceScenes !== undefined)
+            delete config.deviceScenes;
+        if (config.groupScenes !== undefined)
+            delete config.groupScenes;
+        if (config.scenesType === undefined)
+            config.scenesType = 'outlet';
+        if (config.scenesPrefix === undefined)
+            config.scenesPrefix = true;
         if (config.type === 'MatterbridgeExtension') {
             this.z2m = new Zigbee2MQTT(this.mqttHost, this.mqttPort, this.mqttTopic, this.mqttUsername, this.mqttPassword, this.mqttProtocol, this.debugEnabled);
             this.z2m.setLogDebug(this.debugEnabled);
@@ -86,7 +95,6 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         }
         this.log.info(`Initializing platform: ${CYAN}${this.config.name}${nf} version: ${CYAN}${this.config.version}${rs}`);
         this.log.info(`Loaded zigbee2mqtt parameters from ${CYAN}${path.join(matterbridge.matterbridgeDirectory, 'matterbridge-zigbee2mqtt.config.json')}${rs}`);
-        this.clearSelect();
         this.z2m = new Zigbee2MQTT(this.mqttHost, this.mqttPort, this.mqttTopic, this.mqttUsername, this.mqttPassword, this.mqttProtocol, this.debugEnabled);
         this.z2m.setLogDebug(this.debugEnabled);
         this.z2m.setDataPath(path.join(matterbridge.matterbridgePluginDirectory, 'matterbridge-zigbee2mqtt'));
@@ -187,11 +195,14 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
             }
         });
         this.z2m.on('availability', (device, available) => {
-            this.z2mDeviceAvailability.set(device, available);
+            this.z2mEntityAvailability.set(device, available);
             if (available)
-                this.log.info(`zigbee2MQTT device ${device} is ${available ? 'online' : 'offline'}`);
+                this.log.info(`zigbee2MQTT entity ${device} is ${available ? 'online' : 'offline'}`);
             else
-                this.log.warn(`zigbee2MQTT device ${device} is ${available ? 'online' : 'offline'}`);
+                this.log.warn(`zigbee2MQTT entity ${device} is ${available ? 'online' : 'offline'}`);
+        });
+        this.z2m.on('message', (device, payload) => {
+            this.z2mEntityPayload.set(device, payload);
         });
         this.z2m.on('permit_join', async (device, time, status) => {
             this.log.info(`zigbee2MQTT sent permit_join device: ${device} time: ${time} status: ${status}`);
@@ -292,6 +303,9 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     }
     async onStart(reason) {
         this.log.info(`Starting zigbee2mqtt dynamic platform v${this.version}: ` + reason);
+        await this.ready;
+        await this.clearSelect();
+        this.setSelectEntity('scenes', 'Scenes', 'component');
         const hasOnline = await waiter('z2mBridgeOnline', () => this.z2mBridgeOnline !== undefined);
         const hasInfo = await waiter('z2mBridgeInfo', () => this.z2mBridgeInfo !== undefined);
         const hasDevices = await waiter('z2mBridgeDevices & z2mBridgeGroups', () => this.z2mBridgeDevices !== undefined || this.z2mBridgeGroups !== undefined);
@@ -324,33 +338,36 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         await super.onConfigure();
         this.log.info(`Requesting update for ${this.zigbeeEntities.length} zigbee entities.`);
         for (const bridgedEntity of this.zigbeeEntities) {
-            if (bridgedEntity.isDevice && bridgedEntity.device)
-                await this.requestDeviceUpdate(bridgedEntity.device);
-            if (bridgedEntity.isGroup && bridgedEntity.group)
-                await this.requestGroupUpdate(bridgedEntity.group);
             await bridgedEntity.configure();
             if (bridgedEntity.isRouter && bridgedEntity.bridgedDevice) {
                 this.log.info(`Configuring router ${bridgedEntity.bridgedDevice?.deviceName}.`);
                 if (this.z2mBridgeInfo?.permit_join) {
                     bridgedEntity.bridgedDevice?.setAttribute(DoorLock.Cluster.id, 'lockState', DoorLock.LockState.Unlocked, this.log);
-                    if (bridgedEntity.bridgedDevice.number)
+                    if (bridgedEntity.bridgedDevice.maybeNumber)
                         bridgedEntity.bridgedDevice?.triggerEvent(DoorLock.Cluster.id, 'lockOperation', { lockOperationType: DoorLock.LockOperationType.Unlock, operationSource: DoorLock.OperationSource.Manual, userIndex: null, fabricIndex: null, sourceNode: null }, this.log);
                 }
                 else {
                     bridgedEntity.bridgedDevice?.setAttribute(DoorLock.Cluster.id, 'lockState', DoorLock.LockState.Locked, this.log);
-                    if (bridgedEntity.bridgedDevice.number)
+                    if (bridgedEntity.bridgedDevice.maybeNumber)
                         bridgedEntity.bridgedDevice?.triggerEvent(DoorLock.Cluster.id, 'lockOperation', { lockOperationType: DoorLock.LockOperationType.Lock, operationSource: DoorLock.OperationSource.Manual, userIndex: null, fabricIndex: null, sourceNode: null }, this.log);
                 }
             }
+            if (bridgedEntity.isDevice && bridgedEntity.device)
+                await this.requestDeviceUpdate(bridgedEntity.device);
+            if (bridgedEntity.isGroup && bridgedEntity.group)
+                await this.requestGroupUpdate(bridgedEntity.group);
         }
         this.availabilityTimer = setTimeout(() => {
-            for (const [device, available] of this.z2mDeviceAvailability) {
+            for (const [entity, available] of this.z2mEntityAvailability) {
                 if (available)
-                    this.z2m.emit('ONLINE-' + device);
+                    this.z2m.emit('ONLINE-' + entity);
                 else
-                    this.z2m.emit('OFFLINE-' + device);
+                    this.z2m.emit('OFFLINE-' + entity);
+            }
+            for (const [entity, payload] of this.z2mEntityPayload) {
+                this.z2m.emit('MESSAGE-' + entity, payload);
             }
-        }, 60 * 1000);
+        }, 10 * 1000).unref();
         if (this.config.injectPayloads) {
             this.injectTimer = setInterval(() => {
                 const data = this.z2m.readConfig(path.join(this.matterbridge.matterbridgeDirectory, this.config.injectPayloads));
@@ -481,6 +498,22 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         }
         return matterGroup;
     }
+    registerVirtualDevice(name, callback) {
+        let aggregator;
+        if (this.matterbridge.bridgeMode === 'bridge') {
+            aggregator = this.matterbridge.aggregatorNode;
+        }
+        else if (this.matterbridge.bridgeMode === 'childbridge') {
+            aggregator = this.matterbridge.plugins.get(this.name)?.aggregatorNode;
+        }
+        if (aggregator) {
+            if (aggregator.parts.has(name.replaceAll(' ', '') + ':' + this.config.scenesType)) {
+                this.log.warn(`Scene name ${name} already registered. Please use a different name. Changed to ${name + ' ' + this.namePostfix}`);
+                name = name + ' ' + this.namePostfix++;
+            }
+            addVirtualDevice(aggregator, name.slice(0, 32), this.config.scenesType, callback);
+        }
+    }
     async unregisterZigbeeEntity(friendly_name) {
         const entity = this.zigbeeEntities.find((entity) => entity.entityName === friendly_name);
         if (entity) {

package/dist/zigbee2mqtt.js

@@ -70,6 +70,8 @@ export class Zigbee2MQTT extends EventEmitter {
             await mkdir(dataPath, { recursive: true });
             this.mqttDataPath = dataPath;
             this.log.debug(`Data directory ${this.mqttDataPath} created successfully.`);
+            const filePath = path.join(this.mqttDataPath, 'bridge-payloads.txt');
+            fs.unlinkSync(filePath);
         }
         catch (e) {
             const error = e;
@@ -80,6 +82,13 @@ export class Zigbee2MQTT extends EventEmitter {
                 this.log.error('Error creating data directory:', error);
             }
         }
+        try {
+            const filePath = path.join(this.mqttDataPath, 'bridge-payloads.txt');
+            fs.unlinkSync(filePath);
+        }
+        catch (error) {
+            this.log.debug(`Error deleting bridge-payloads.txt: ${error}`);
+        }
     }
     getUrl() {
         return 'mqtt://' + this.mqttHost + ':' + this.mqttPort.toString();
@@ -613,6 +622,7 @@ export class Zigbee2MQTT extends EventEmitter {
         else if (service === 'set') {
         }
         else if (service === undefined) {
+            this.emit('message', entity, data);
             this.emit('MESSAGE-' + entity, data);
         }
         else {

package/matterbridge-zigbee2mqtt.schema.json

@@ -119,28 +119,39 @@
         "selectDeviceEntityFrom": "name"
       }
     },
-    "deviceScenes": {
-      "description": "Enable the devices scenes",
-      "type": "boolean",
-      "default": false,
-      "ui:widget": "hidden"
-    },
-    "groupScenes": {
-      "description": "Enable the groups scenes",
+    "scenesType": {
+      "description": "Device type to use to expose scenes",
+      "type": "string",
+      "oneOf": [
+        {
+          "title": "Light",
+          "enum": ["light"]
+        },
+        {
+          "title": "Outlet",
+          "enum": ["outlet"]
+        },
+        {
+          "title": "Switch",
+          "enum": ["switch"]
+        },
+        {
+          "title": "Mounted Switch",
+          "enum": ["mounted_switch"]
+        }
+      ],
+      "default": "outlet"
+    },
+    "scenesPrefix": {
+      "description": "Add the device/group friendly name before the scene name.",
       "type": "boolean",
-      "default": false,
-      "ui:widget": "hidden"
+      "default": true
     },
     "postfix": {
       "description": "Add this unique postfix (3 characters max) to each device serial to avoid collision with other instances (you may loose the configuration of the devices in your controller when changing this value).",
       "type": "string",
       "default": ""
     },
-    "postfixHostname": {
-      "description": "DEPRECATED: unique postfix added to each device identifier to avoid collision with other instances (you may loose the configuration of the devices in your controller when changing this value). Use postfix instead.",
-      "type": "boolean",
-      "default": true
-    },
     "debug": {
       "description": "Enable the debug for the plugin (development only)",
       "type": "boolean",

package/npm-shrinkwrap.json

@@ -1,16 +1,16 @@
 {
   "name": "matterbridge-zigbee2mqtt",
-  "version": "2.4.7",
+  "version": "2.5.0-dev.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge-zigbee2mqtt",
-      "version": "2.4.7",
+      "version": "2.5.0-dev.3",
       "license": "Apache-2.0",
       "dependencies": {
         "moment": "2.30.1",
-        "mqtt": "5.10.4",
+        "mqtt": "5.13.0",
         "node-ansi-logger": "3.0.1",
         "node-persist-manager": "1.0.8"
       },
@@ -23,40 +23,27 @@
       }
     },
     "node_modules/@babel/runtime": {
-      "version": "7.26.10",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.10.tgz",
-      "integrity": "sha512-2WJMeRQPHKSPemqk/awGrAiuFfzBmOIPXKizAsVhWH9YJqLZ0H+HS4c8loHGgW6utJ3E/ejXQUsiGaQy2NZ9Fw==",
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.1.tgz",
+      "integrity": "sha512-1x3D2xEk2fRo3PAhwQwu5UubzgiVWSXTBfWpVd2Mx2AzRqJuDJCsgaDVZ7HB5iGzDW1Hl1sWN2mFyKjmR9uAog==",
       "license": "MIT",
-      "dependencies": {
-        "regenerator-runtime": "^0.14.0"
-      },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@types/node": {
-      "version": "22.13.10",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.13.10.tgz",
-      "integrity": "sha512-I6LPUvlRH+O6VRUqYOcMudhaIdUVWfsjnZavnsraHvpBwaEyMN29ry+0UVJhImYL16xsscu0aske3yA+uPOWfw==",
+      "version": "22.15.21",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.21.tgz",
+      "integrity": "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==",
       "license": "MIT",
       "dependencies": {
-        "undici-types": "~6.20.0"
+        "undici-types": "~6.21.0"
       }
     },
     "node_modules/@types/readable-stream": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-4.0.18.tgz",
-      "integrity": "sha512-21jK/1j+Wg+7jVw1xnSwy/2Q1VgVjWuFssbYGTREPUBeZ+rqVFl2udq0IkxzPC0ZhOzVceUbyIACFZKLqKEBlA==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*",
-        "safe-buffer": "~5.1.1"
-      }
-    },
-    "node_modules/@types/ws": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.0.tgz",
-      "integrity": "sha512-8svvI3hMyvN0kKCJMvTJP/x6Y/EoQbepff882wL+Sn5QsXb3etnamgrJq4isrBxSJj5L2AuXcI0+bgkoAXGUJw==",
+      "version": "4.0.19",
+      "resolved": "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-4.0.19.tgz",
+      "integrity": "sha512-6Tgd3lMocKwOul/kwAAgSebkhdMCLhRvcJ6CKHA6wdql2qNIwK6hw3Y4PZQxn9HcJogoC/1ZOmkFM7OZKH/VrA==",
       "license": "MIT",
       "dependencies": {
         "@types/node": "*"
@@ -172,9 +159,9 @@
       }
     },
     "node_modules/debug": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
-      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
       "license": "MIT",
       "dependencies": {
         "ms": "^2.1.3"
@@ -251,6 +238,19 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
+    "node_modules/ip-address": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz",
+      "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==",
+      "license": "MIT",
+      "dependencies": {
+        "jsbn": "1.1.0",
+        "sprintf-js": "^1.1.3"
+      },
+      "engines": {
+        "node": ">= 12"
+      }
+    },
     "node_modules/js-sdsl": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.3.0.tgz",
@@ -261,6 +261,12 @@
         "url": "https://opencollective.com/js-sdsl"
       }
     },
+    "node_modules/jsbn": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz",
+      "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==",
+      "license": "MIT"
+    },
     "node_modules/minimist": {
       "version": "1.2.8",
       "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
@@ -280,24 +286,22 @@
       }
     },
     "node_modules/mqtt": {
-      "version": "5.10.4",
-      "resolved": "https://registry.npmjs.org/mqtt/-/mqtt-5.10.4.tgz",
-      "integrity": "sha512-wN+SuhT2/ZaG6NPxca0N6YtRivnMxk6VflxQUEeqDH4erKdj+wPAGhHmcTLzvqfE4sJRxrEJ+XJxUc0No0E7eQ==",
+      "version": "5.13.0",
+      "resolved": "https://registry.npmjs.org/mqtt/-/mqtt-5.13.0.tgz",
+      "integrity": "sha512-pR+z+ChxFl3n8AKLQbTONVOOg/jl4KiKQRBAi78tjd6PksOWvl1nl9L8ZHOZ3MiavZfrUOjok2ddwc1VymGWRg==",
       "license": "MIT",
       "dependencies": {
-        "@types/readable-stream": "^4.0.18",
-        "@types/ws": "^8.5.14",
         "commist": "^3.2.0",
         "concat-stream": "^2.0.0",
         "debug": "^4.4.0",
         "help-me": "^5.0.0",
         "lru-cache": "^10.4.3",
         "minimist": "^1.2.8",
-        "mqtt-packet": "^9.0.1",
+        "mqtt-packet": "^9.0.2",
         "number-allocator": "^1.0.14",
         "readable-stream": "^4.7.0",
-        "reinterval": "^1.1.0",
         "rfdc": "^1.4.1",
+        "socks": "^2.8.3",
         "split2": "^4.2.0",
         "worker-timers": "^7.1.8",
         "ws": "^8.18.0"
@@ -431,18 +435,6 @@
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       }
     },
-    "node_modules/regenerator-runtime": {
-      "version": "0.14.1",
-      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
-      "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
-      "license": "MIT"
-    },
-    "node_modules/reinterval": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/reinterval/-/reinterval-1.1.0.tgz",
-      "integrity": "sha512-QIRet3SYrGp0HUHO88jVskiG6seqUGC5iAG7AwI/BV4ypGcuqk9Du6YQBUOUqm9c8pw1eyLoIaONifRua1lsEQ==",
-      "license": "MIT"
-    },
     "node_modules/rfdc": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
@@ -450,11 +442,49 @@
       "license": "MIT"
     },
     "node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
       "license": "MIT"
     },
+    "node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks": {
+      "version": "2.8.4",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.4.tgz",
+      "integrity": "sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^9.0.5",
+        "smart-buffer": "^4.2.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
     "node_modules/split2": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
@@ -464,6 +494,12 @@
         "node": ">= 10.x"
       }
     },
+    "node_modules/sprintf-js": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
+      "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/string_decoder": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
@@ -473,26 +509,6 @@
         "safe-buffer": "~5.2.0"
       }
     },
-    "node_modules/string_decoder/node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
     "node_modules/tslib": {
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -506,9 +522,9 @@
       "license": "MIT"
     },
     "node_modules/undici-types": {
-      "version": "6.20.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
-      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
       "license": "MIT"
     },
     "node_modules/util-deprecate": {
@@ -552,9 +568,9 @@
       }
     },
     "node_modules/ws": {
-      "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz",
-      "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==",
+      "version": "8.18.2",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz",
+      "integrity": "sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-zigbee2mqtt",
-  "version": "2.4.7",
+  "version": "2.5.0-dev.3",
   "description": "Matterbridge zigbee2mqtt plugin",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "moment": "2.30.1",
-    "mqtt": "5.10.4",
+    "mqtt": "5.13.0",
     "node-ansi-logger": "3.0.1",
     "node-persist-manager": "1.0.8"
   }

package/tsconfig.jest.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    // enable isolatedModules just for ts-jest
+    "isolatedModules": true
+  },
+  "include": ["**/*.spec.ts", "**/*.test.ts", "**/__test__/*"]
+}