matterbridge-zigbee2mqtt 2.4.2 → 2.4.4-dev.1

package/dist/entity.js

@@ -1,37 +1,13 @@
-/**
- * This file contains the classes ZigbeeEntity, ZigbeeDevice and ZigbeeGroup.
- *
- * @file entity.ts
- * @author Luca Liguori
- * @date 2023-12-29
- * @version 3.1.0
- *
- * Copyright 2023, 2024, 2025 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License. *
- */
-import { MatterbridgeDevice, airQualitySensor, colorTemperatureSwitch, dimmableSwitch, onOffSwitch, OnOff, LevelControl, ColorControl, ColorControlCluster, TemperatureMeasurement, BooleanState, RelativeHumidityMeasurement, PressureMeasurement, OccupancySensing, IlluminanceMeasurement, PowerSource, ClusterId, WindowCovering, DoorLock, BridgedDeviceBasicInformation, ThermostatCluster, Thermostat, getClusterNameById, powerSource, bridgedNode, AirQuality, TotalVolatileOrganicCompoundsConcentrationMeasurement, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FormaldehydeConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, Pm10ConcentrationMeasurement, electricalSensor, ElectricalEnergyMeasurement, ElectricalPowerMeasurement, onOffLight, dimmableLight, colorTemperatureLight, onOffOutlet, SwitchesTag, NumberTag, coverDevice, thermostatDevice, MatterbridgeEndpoint, dimmableOutlet, doorLockDevice, occupancySensor, lightSensor, contactSensor, temperatureSensor, humiditySensor, pressureSensor, genericSwitch, OnOffCluster, LevelControlCluster, WindowCoveringCluster, DoorLockCluster, } from 'matterbridge';
+import { airQualitySensor, colorTemperatureSwitch, dimmableSwitch, onOffSwitch, OnOff, LevelControl, ColorControl, ColorControlCluster, TemperatureMeasurement, BooleanState, RelativeHumidityMeasurement, PressureMeasurement, OccupancySensing, IlluminanceMeasurement, PowerSource, ClusterId, WindowCovering, DoorLock, BridgedDeviceBasicInformation, ThermostatCluster, Thermostat, getClusterNameById, powerSource, bridgedNode, AirQuality, TotalVolatileOrganicCompoundsConcentrationMeasurement, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FormaldehydeConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, Pm10ConcentrationMeasurement, electricalSensor, ElectricalEnergyMeasurement, ElectricalPowerMeasurement, onOffLight, dimmableLight, colorTemperatureLight, onOffOutlet, SwitchesTag, NumberTag, coverDevice, thermostatDevice, MatterbridgeEndpoint, dimmableOutlet, doorLockDevice, occupancySensor, lightSensor, contactSensor, temperatureSensor, humiditySensor, pressureSensor, genericSwitch, OnOffCluster, LevelControlCluster, WindowCoveringCluster, DoorLockCluster, } 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 { PowerSourceBehavior } from 'matterbridge/matter';
 import * as color from 'matterbridge/utils';
 import EventEmitter from 'events';
 import { hostname } from 'os';
-/**
- * Represents a Zigbee entity: a group or a device.
- *
- * @class
- * @extends {EventEmitter}
- */
+function require(type, options) {
+    return { clusterId: ClusterId(1), options };
+}
 export class ZigbeeEntity extends EventEmitter {
     log;
     serial = '';
@@ -51,7 +27,6 @@ export class ZigbeeEntity extends EventEmitter {
     ignoreFeatures = [];
     transition = false;
     propertyMap = new Map();
-    // We save the tag list and device types and cluster servers and clients to avoid multiple lookups
     mutableDevice = new Map();
     colorTimeout = undefined;
     thermostatTimeout = undefined;
@@ -59,12 +34,6 @@ export class ZigbeeEntity extends EventEmitter {
     hasEndpoints = false;
     isRouter = false;
     noUpdate = false;
-    /**
-     * Creates an instance of ZigbeeEntity.
-     *
-     * @param {ZigbeePlatform} platform - The Zigbee platform instance.
-     * @param {BridgeDevice | BridgeGroup} entity - The bridge device or group instance received from zigbee2mqtt.
-     */
     constructor(platform, entity) {
         super();
         this.platform = platform;
@@ -82,26 +51,22 @@ export class ZigbeeEntity extends EventEmitter {
             this.en = gn;
             this.ien = ign;
         }
-        this.log = new AnsiLogger({ logName: this.entityName, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: platform.debugEnabled ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */ });
+        this.log = new AnsiLogger({ logName: this.entityName, logTimestampFormat: 4, logLevel: platform.debugEnabled ? "debug" : "info" });
         this.log.debug(`Created MatterEntity: ${this.entityName}`);
         this.platform.z2m.on('MESSAGE-' + this.entityName, (payload) => {
-            // Check if the message is a duplicate that can be ingored cause only linkquality and last_seen have changed (action is always passed)
             const now = Date.now();
             if (now - this.lastSeen < 1000 * 60 && deepEqual(this.lastPayload, payload, ['linkquality', 'last_seen', ...this.ignoreFeatures]) && !Object.prototype.hasOwnProperty.call(this.lastPayload, 'action')) {
                 this.log.debug(`Skipping not changed ${platform.z2mDevicesRegistered ? 'MQTT message' : 'State update'} for accessory ${this.entityName}`);
                 return;
             }
             this.lastSeen = Date.now();
-            // Check and deep copy the payload
             if (deepEqual(this.lastPayload, payload, this.ignoreFeatures))
                 return;
             this.lastPayload = deepCopy(payload);
             if (Object.prototype.hasOwnProperty.call(this.lastPayload, 'action'))
                 delete this.lastPayload.action;
-            // Remove each key in ignoreFeatures from the payload copy
             for (const key of this.ignoreFeatures) {
                 if (Object.prototype.hasOwnProperty.call(payload, key)) {
-                    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                     delete payload[key];
                     this.log.debug(`Removed key ${CYAN}${key}${db} from payload`);
                 }
@@ -115,17 +80,13 @@ export class ZigbeeEntity extends EventEmitter {
                 return;
             }
             this.log.info(`${db}${platform.z2mDevicesRegistered ? 'MQTT message' : 'State update'} for device ${this.ien}${this.entityName}${rs}${db} payload: ${debugStringify(payload)}`);
-            // Parse the payload and update the accessory
             Object.entries(payload).forEach(([key, value]) => {
-                // Skip null and undefined values
                 if (value === undefined || value === null)
                     return;
                 if (this.bridgedDevice === undefined || this.noUpdate)
                     return;
-                // Modify voltage to battery_voltage
                 if (key === 'voltage' && this.isDevice && this.device?.power_source === 'Battery')
                     key = 'battery_voltage';
-                // Lookup the property in the propertyMap and ZigbeeToMatter table
                 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} ` +
@@ -145,21 +106,16 @@ export class ZigbeeEntity extends EventEmitter {
                 }
                 else
                     this.log.debug(`*Payload entry ${CYAN}${key}${db} not found in propertyMap`);
-                // Switch actions on the endpoints
                 if (key === 'action' && value !== '') {
                     const propertyMap = this.propertyMap.get(('action_' + value));
                     if (propertyMap) {
-                        // this.log.debug(`Payload entry ${CYAN}${value}${db} => name: ${CYAN}${propertyMap.name}${db} endpoint: ${CYAN}${propertyMap.endpoint}${db} action: ${CYAN}${propertyMap.action}${db}`);
                         const child = this.bridgedDevice.getChildEndpointByName(propertyMap.endpoint);
                         if (child && child.number)
-                            this.bridgedDevice.triggerSwitchEvent(propertyMap.action, this.log, child);
+                            child.triggerSwitchEvent(propertyMap.action, this.log);
                     }
                     else
                         this.log.debug(`*Payload entry ${CYAN}${('action_' + value)}${db} not found in propertyMap`);
                 }
-                // WindowCovering
-                // Zigbee2MQTT cover: 0 = open, 100 = closed
-                // Matter WindowCovering: 0 = open 10000 = closed
                 if (key === 'position' && this.isDevice && isValidNumber(value, 0, 100)) {
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, WindowCovering.Cluster.id, 'currentPositionLiftPercent100ths', value * 100);
                 }
@@ -180,26 +136,17 @@ export class ZigbeeEntity extends EventEmitter {
                         this.updateAttributeIfChanged(this.bridgedDevice, undefined, WindowCovering.Cluster.id, 'targetPositionLiftPercent100ths', position);
                     }
                 }
-                // ColorControl colorTemperatureMired and colorMode
                 if (key === 'color_temp' && 'color_mode' in payload && payload['color_mode'] === 'color_temp') {
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds);
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'colorTemperatureMireds', Math.max(147, Math.min(500, typeof value === 'number' ? value : 0)));
                 }
-                // ColorControl currentHue, currentSaturation and colorMode
                 if (key === 'color' && 'color_mode' in payload && payload['color_mode'] === 'hs') {
                     const { hue, saturation } = value;
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation);
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'currentHue', Math.round((hue / 360) * 254));
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'currentSaturation', Math.round((saturation / 100) * 254));
                 }
-                // ColorControl currentX, currentY and colorMode
                 if (key === 'color' && 'color_mode' in payload && payload['color_mode'] === 'xy') {
-                    /* not supported by Apple Home so we convert xy to hue and saturation
-                    const { x, y } = value as { x: number; y: number };
-                    this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.CurrentXAndCurrentY);
-                    this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'currentX', Math.max(Math.min(Math.round(x * 65536), 65279), 0));
-                    this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'currentY', Math.max(Math.min(Math.round(y * 65536), 65279), 0));
-                    */
                     const { x, y } = value;
                     const hsl = color.xyToHsl(x, y);
                     const rgb = color.xyColorToRgbColor(x, y);
@@ -226,13 +173,6 @@ export class ZigbeeEntity extends EventEmitter {
             }
         });
     }
-    /**
-     * Destroys the ZigbeeEntity instance by clearing any active timeouts.
-     *
-     * @remarks
-     * This method is used to clean up the ZigbeeEntity instance by clearing any active timeouts for color and thermostat operations.
-     * It ensures that no further actions are taken on these timeouts after the entity is destroyed.
-     */
     destroy() {
         if (this.colorTimeout)
             clearTimeout(this.colorTimeout);
@@ -241,107 +181,58 @@ export class ZigbeeEntity extends EventEmitter {
             clearTimeout(this.thermostatTimeout);
         this.thermostatTimeout = undefined;
     }
-    /**
-     * Creates a mutable device with the specified definition and includes the specified server list.
-     *
-     * @param {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The device type definition.
-     * @param {ClusterId[]} [includeServerList=[]] - The list of server clusters to include.
-     * @param {EndpointOptions} [options] - Optional endpoint options.
-     * @param {boolean} [debug] - Optional debug flag.
-     * @returns {MatterbridgeDevice} The created mutable device.
-     *
-     * @remarks
-     * This method creates a mutable device based on the provided definition. It adds the specified server clusters
-     * to the device and configures the device with basic information and power source clusters. If the device is a
-     * coordinator, it sets up the basic information cluster with coordinator-specific details. If the device is a
-     * group, it sets up the basic information cluster with group-specific details. The method also configures the
-     * power source cluster based on the device's power source.
-     */
-    async createMutableDevice(definition, options, debug) {
-        if (this.platform.matterbridge.edge === true) {
-            this.bridgedDevice = (await MatterbridgeEndpoint.loadInstance(definition, options, debug));
-        }
-        else {
-            this.bridgedDevice = await MatterbridgeDevice.loadInstance(definition, undefined, debug);
-        }
-        return this.bridgedDevice;
-    }
-    getBridgedDeviceBasicInformation() {
+    addBridgedDeviceBasicInformation() {
         if (!this.bridgedDevice)
             throw new Error('No bridged device');
-        // Add BridgedDeviceBasicInformation cluster and device type
         const softwareVersion = parseInt(this.platform.z2mBridgeInfo?.version || '1');
         const softwareVersionString = `${this.platform.z2mBridgeInfo?.version} (commit ${this.platform.z2mBridgeInfo?.commit})`;
         const hardwareVersion = parseInt(this.platform.matterbridge.matterbridgeVersion || '1');
         const hardwareVersionString = this.platform.matterbridge.matterbridgeVersion || 'unknown';
         if (this.isDevice && this.device && this.device.friendly_name === 'Coordinator') {
-            return this.bridgedDevice.getDefaultBridgedDeviceBasicInformationClusterServer(this.device.friendly_name, this.serial, 0xfff1, 'zigbee2MQTT', 'Coordinator', softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString);
+            this.bridgedDevice.createDefaultBridgedDeviceBasicInformationClusterServer(this.device.friendly_name, this.serial, 0xfff1, 'zigbee2MQTT', 'Coordinator', softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString);
+            return this.bridgedDevice;
         }
         else if (this.isDevice && this.device) {
-            return this.bridgedDevice.getDefaultBridgedDeviceBasicInformationClusterServer(this.device.friendly_name, this.serial, 0xfff1, this.device.definition ? this.device.definition.vendor : this.device.manufacturer, this.device.definition ? this.device.definition.model : this.device.model_id, softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString);
+            this.bridgedDevice.createDefaultBridgedDeviceBasicInformationClusterServer(this.device.friendly_name, this.serial, 0xfff1, this.device.definition ? this.device.definition.vendor : this.device.manufacturer, this.device.definition ? this.device.definition.model : this.device.model_id, softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString);
+            return this.bridgedDevice;
         }
         if (!this.group)
             throw new Error('No group found');
-        return this.bridgedDevice.getDefaultBridgedDeviceBasicInformationClusterServer(this.group.friendly_name, this.serial, 0xfff1, 'zigbee2MQTT', 'Group', softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString);
-    }
-    addBridgedDeviceBasicInformation() {
-        if (!this.bridgedDevice)
-            throw new Error('No bridged device');
-        // Add BridgedDeviceBasicInformation cluster and device type
-        this.bridgedDevice.addDeviceType(bridgedNode);
-        this.bridgedDevice.addClusterServer(this.getBridgedDeviceBasicInformation());
+        this.bridgedDevice.createDefaultBridgedDeviceBasicInformationClusterServer(this.group.friendly_name, this.serial, 0xfff1, 'zigbee2MQTT', 'Group', softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString);
         return this.bridgedDevice;
     }
-    getPowerSource() {
+    addPowerSource() {
         if (!this.bridgedDevice)
             throw new Error('No bridged device');
         if (this.isDevice) {
             if (this.device?.power_source === 'Battery') {
-                return this.bridgedDevice.getDefaultPowerSourceReplaceableBatteryClusterServer(100, PowerSource.BatChargeLevel.Ok);
+                this.bridgedDevice.createDefaultPowerSourceReplaceableBatteryClusterServer(100, PowerSource.BatChargeLevel.Ok);
             }
             else {
-                return this.bridgedDevice?.getDefaultPowerSourceWiredClusterServer();
+                this.bridgedDevice.createDefaultPowerSourceWiredClusterServer();
             }
         }
-        return this.bridgedDevice?.getDefaultPowerSourceWiredClusterServer();
-    }
-    addPowerSource() {
-        if (!this.bridgedDevice)
-            throw new Error('No bridged device');
-        // Add PowerSource device type and cluster
-        this.bridgedDevice.addDeviceType(powerSource);
-        this.bridgedDevice.addClusterServer(this.getPowerSource());
+        if (this.isGroup) {
+            this.bridgedDevice.createDefaultPowerSourceWiredClusterServer();
+        }
         return this.bridgedDevice;
     }
-    /**
-     * Verifies that all required server clusters are present on the main endpoint and child endpoints.
-     *
-     * @param {MatterbridgeDevice} endpoint - The device endpoint to verify.
-     * @returns {boolean} True if all required server clusters are present, false otherwise.
-     *
-     * @remarks
-     * This method checks if all required server clusters are present on the main endpoint and its child endpoints.
-     * It logs an error message if any required server cluster is missing and returns false. If all required server
-     * clusters are present, it returns true.
-     */
     verifyMutableDevice(endpoint) {
         if (!endpoint)
             return false;
-        // Verify that all required server clusters are present in the main endpoint and in the child endpoints
         for (const deviceType of endpoint.getDeviceTypes()) {
             for (const clusterId of deviceType.requiredServerClusters) {
-                if (!endpoint.getClusterServerById(clusterId)) {
-                    endpoint.addClusterServerFromList(endpoint, [clusterId]);
+                if (!endpoint.hasClusterServer(clusterId)) {
+                    endpoint.addClusterServers([clusterId]);
                     this.log.warn(`Endpoint with device type ${deviceType.name} (0x${deviceType.code.toString(16)}) requires cluster server ${getClusterNameById(clusterId)} (0x${clusterId.toString(16)}) but it is not present on endpoint`);
                 }
             }
         }
-        // Verify that all required server clusters are present in the child endpoints
         for (const childEndpoint of endpoint.getChildEndpoints()) {
             for (const deviceType of childEndpoint.getDeviceTypes()) {
                 for (const clusterId of deviceType.requiredServerClusters) {
-                    if (!childEndpoint.getClusterServerById(clusterId)) {
-                        endpoint.addClusterServerFromList(childEndpoint, [clusterId]);
+                    if (!childEndpoint.hasClusterServer(clusterId)) {
+                        childEndpoint.addClusterServers([clusterId]);
                         this.log.warn(`Child endpoint with device type ${deviceType.name} (0x${deviceType.code.toString(16)}) requires cluster server ${getClusterNameById(clusterId)} (0x${clusterId.toString(16)}) but it is not present on child endpoint`);
                     }
                 }
@@ -349,23 +240,12 @@ export class ZigbeeEntity extends EventEmitter {
         }
         return true;
     }
-    /**
-     * Configures the device by setting up the WindowCovering and DoorLock clusters if they are present.
-     *
-     * @returns {Promise<void>} A promise that resolves when the configuration is complete.
-     *
-     * @remarks
-     * This method configures the device by checking for the presence of the WindowCovering and DoorLock clusters.
-     * If the WindowCovering cluster is present, it sets the target as the current position and stops any ongoing
-     * movement. If the DoorLock cluster is present, it retrieves the lock state and triggers the appropriate lock
-     * operation event based on the current state.
-     */
     async configure() {
-        if (this.bridgedDevice?.getClusterServerById(WindowCovering.Cluster.id)) {
+        if (this.bridgedDevice?.hasClusterServer(WindowCovering.Cluster.id)) {
             this.log.info(`Configuring ${this.bridgedDevice?.deviceName} WindowCovering cluster`);
             await this.bridgedDevice?.setWindowCoveringTargetAsCurrentAndStopped();
         }
-        if (this.bridgedDevice?.getClusterServerById(DoorLock.Cluster.id)) {
+        if (this.bridgedDevice?.hasClusterServer(DoorLock.Cluster.id)) {
             this.log.info(`Configuring ${this.bridgedDevice?.deviceName} DoorLock cluster`);
             const state = this.bridgedDevice?.getAttribute(DoorLock.Cluster.id, 'lockState', this.log);
             if (this.bridgedDevice.maybeNumber) {
@@ -376,32 +256,15 @@ export class ZigbeeEntity extends EventEmitter {
             }
         }
     }
-    /**
-     * Updates the attribute of a cluster on a device endpoint if the value has changed.
-     *
-     * @param {Endpoint} deviceEndpoint - The device endpoint to update.
-     * @param {string | undefined} childEndpointName - The name of the child endpoint, if any.
-     * @param {number} clusterId - The ID of the cluster to update.
-     * @param {string} attributeName - The name of the attribute to update.
-     * @param {PayloadValue} value - The new value of the attribute.
-     * @param {string[]} [lookup] - Optional lookup array for converting string values to indices.
-     *
-     * @remarks
-     * This method checks if the specified attribute of a cluster on a device endpoint has changed. If the attribute
-     * has changed, it updates the attribute with the new value. If a lookup array is provided, it converts string
-     * values to their corresponding indices in the lookup array. The method logs the update process and handles any
-     * errors that occur during the update.
-     */
     updateAttributeIfChanged(deviceEndpoint, childEndpointName, clusterId, attributeName, value, lookup) {
         if (childEndpointName && childEndpointName !== '') {
             deviceEndpoint = this.bridgedDevice?.getChildEndpointByName(childEndpointName) ?? deviceEndpoint;
         }
-        const cluster = deviceEndpoint.getClusterServerById(ClusterId(clusterId));
-        if (cluster === undefined) {
+        if (!deviceEndpoint.hasClusterServer(ClusterId(clusterId))) {
             this.log.debug(`Update endpoint ${this.eidn}${deviceEndpoint.name}:${deviceEndpoint.number}${db}${childEndpointName ? ' (' + zb + childEndpointName + db + ')' : ''} cluster ${hk}${clusterId}${db}-${hk}${getClusterNameById(ClusterId(clusterId))}${db} not found: is z2m converter exposing all features?`);
             return;
         }
-        if (!cluster.isAttributeSupportedByName(attributeName)) {
+        if (!deviceEndpoint.hasAttributeServer(ClusterId(clusterId), attributeName)) {
             this.log.debug(`Update endpoint ${this.eidn}${deviceEndpoint.name}:${deviceEndpoint.number}${db}${childEndpointName ? ' (' + zb + childEndpointName + db + ')' : ''} error attribute ${hk}${clusterId}${db}-${hk}${getClusterNameById(ClusterId(clusterId))}${db}.${hk}${attributeName}${db} not found`);
             return;
         }
@@ -415,7 +278,7 @@ export class ZigbeeEntity extends EventEmitter {
                 return;
             }
         }
-        const localValue = this.bridgedDevice?.getAttribute(ClusterId(clusterId), attributeName, undefined, deviceEndpoint);
+        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 + ')' : ''} ` +
                 `attribute ${getClusterNameById(ClusterId(clusterId))}.${attributeName} already ${typeof value === 'object' ? debugStringify(value) : value}`);
@@ -424,24 +287,12 @@ export class ZigbeeEntity extends EventEmitter {
         this.log.info(`${db}Update endpoint ${this.eidn}${deviceEndpoint.name}:${deviceEndpoint.number}${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 {
-            this.bridgedDevice?.setAttribute(ClusterId(clusterId), attributeName, value, undefined, deviceEndpoint);
+            deviceEndpoint.setAttribute(ClusterId(clusterId), attributeName, value, undefined);
         }
         catch (error) {
             this.log.error(`Error setting attribute ${hk}${getClusterNameById(ClusterId(clusterId))}${er}.${hk}${attributeName}${er} to ${value}: ${error}`);
         }
     }
-    /**
-     * Publishes a command to the specified entity with the given payload.
-     *
-     * @param {string} command - The command to execute.
-     * @param {string} entityName - The name of the entity to publish the command to.
-     * @param {Payload} payload - The payload of the command.
-     *
-     * @remarks
-     * This method logs the execution of the command and publishes the command to the specified entity.
-     * If the entity name starts with 'bridge/request', it publishes the payload without a 'set' suffix.
-     * Otherwise, it publishes the payload with a 'set' suffix.
-     */
     publishCommand(command, entityName, payload) {
         this.log.debug(`executeCommand ${command} called for ${this.ien}${entityName}${rs}${db} payload: ${debugStringify(payload)}`);
         if (entityName.startsWith('bridge/request')) {
@@ -451,16 +302,7 @@ export class ZigbeeEntity extends EventEmitter {
             this.platform.publish(entityName, 'set', JSON.stringify(payload));
         }
     }
-    /**
-     * Logs the property map of the Zigbee entity.
-     *
-     * @remarks
-     * This method iterates over the property map of the Zigbee entity and logs each property's details,
-     * including its name, type, values, minimum and maximum values, unit, and endpoint.
-     */
-    // zigbeeDevice.propertyMap.set(property, { name, type, endpoint, category, description, label, unit, value_min, value_max, values: value });
     logPropertyMap() {
-        // Log properties
         this.propertyMap.forEach((value, key) => {
             this.log.debug(`Property ${CYAN}${key}${db} name ${CYAN}${value.name}${db} type ${CYAN}${value.type === '' ? 'generic' : value.type}${db} endpoint ${CYAN}${value.endpoint === '' ? 'main' : value.endpoint}${db} ` +
                 `category ${CYAN}${value.category}${db} description ${CYAN}${value.description}${db} label ${CYAN}${value.label}${db} unit ${CYAN}${value.unit}${db} ` +
@@ -468,33 +310,10 @@ export class ZigbeeEntity extends EventEmitter {
         });
     }
 }
-/**
- * Represents a Zigbee group entity.
- *
- * @class
- * @extends {ZigbeeEntity}
- */
 export class ZigbeeGroup extends ZigbeeEntity {
-    /**
-     * Creates an instance of ZigbeeGroup.
-     *
-     * @param {ZigbeePlatform} platform - The Zigbee platform instance.
-     * @param {BridgeGroup} group - The bridge group instance.
-     */
     constructor(platform, group) {
         super(platform, group);
     }
-    /**
-     * Creates a new ZigbeeGroup instance.
-     *
-     * @param {ZigbeePlatform} platform - The Zigbee platform instance.
-     * @param {BridgeGroup} group - The bridge group instance.
-     * @returns {Promise<ZigbeeGroup>} A promise that resolves to the created ZigbeeGroup instance.
-     *
-     * @remarks
-     * This method initializes a new ZigbeeGroup instance, sets up its properties, and configures the device
-     * based on the group members. It also adds command handlers for the group.
-     */
     static async create(platform, group) {
         const zigbeeGroup = new ZigbeeGroup(platform, group);
         if (zigbeeGroup.platform.postfixHostname) {
@@ -503,7 +322,6 @@ export class ZigbeeGroup extends ZigbeeEntity {
         else {
             zigbeeGroup.serial = `group-${group.id}`.slice(0, 32);
         }
-        // Set the device entity select
         zigbeeGroup.log.warn(`***Group ${zigbeeGroup.en}${group.friendly_name}${db} adds select device ${group.id} (${group.friendly_name})`);
         if (!platform.selectDevice.get(`group-${group.id}`)) {
             platform.selectDevice.set(`group-${group.id}`, { serial: `group-${group.id}`, name: group.friendly_name, icon: 'wifi', entities: [] });
@@ -519,23 +337,19 @@ export class ZigbeeGroup extends ZigbeeEntity {
         let isCover = false;
         let isThermostat = false;
         if (group.members.length === 0) {
-            // Create a virtual device for the empty group to use in automations
             zigbeeGroup.log.debug(`Group: ${gn}${group.friendly_name}${rs}${db} is a ${CYAN}virtual${db} group`);
-            zigbeeGroup.bridgedDevice = await zigbeeGroup.createMutableDevice([onOffSwitch], { uniqueStorageKey: group.friendly_name }, zigbeeGroup.log.logLevel === "debug" /* LogLevel.DEBUG */);
+            zigbeeGroup.bridgedDevice = new MatterbridgeEndpoint([onOffSwitch, bridgedNode, powerSource], { uniqueStorageKey: group.friendly_name }, zigbeeGroup.log.logLevel === "debug");
             isSwitch = true;
             zigbeeGroup.propertyMap.set('state', { name: 'state', type: 'switch', endpoint: '' });
         }
         else {
-            // Create a switch or light or outlet device for the group
             group.members.forEach((member) => {
-                // const device = zigbeeGroup.platform.z2m.getDevice(member.ieee_address);
                 const device = zigbeeGroup.platform.z2mBridgeDevices?.find((device) => device.ieee_address === member.ieee_address);
                 if (!device)
                     return;
                 zigbeeGroup.log.debug(`Group ${gn}${group.friendly_name}${db}: member device ${dn}${device.friendly_name}${db}`);
                 device.definition?.exposes.forEach((expose) => {
                     if (expose.features) {
-                        // Specific features with type
                         expose.features?.forEach((feature) => {
                             if (expose.type === 'lock' && feature.name === 'state' && feature.property === 'child_lock') {
                                 expose.type = 'child_lock';
@@ -565,7 +379,6 @@ export class ZigbeeGroup extends ZigbeeEntity {
                         });
                     }
                     else {
-                        // Generic features without type
                         zigbeeGroup.log.debug(`- generic type ${CYAN}${expose.type}${db} expose name ${CYAN}${expose.name}${db} property ${CYAN}${expose.property}${db}`);
                     }
                 });
@@ -611,17 +424,14 @@ export class ZigbeeGroup extends ZigbeeEntity {
             }
             if (!deviceType)
                 return zigbeeGroup;
-            zigbeeGroup.bridgedDevice = await zigbeeGroup.createMutableDevice([deviceType], { uniqueStorageKey: group.friendly_name }, zigbeeGroup.log.logLevel === "debug" /* LogLevel.DEBUG */);
+            zigbeeGroup.bridgedDevice = new MatterbridgeEndpoint([deviceType, bridgedNode, powerSource], { uniqueStorageKey: group.friendly_name }, zigbeeGroup.log.logLevel === "debug");
         }
         zigbeeGroup.addBridgedDeviceBasicInformation();
         zigbeeGroup.addPowerSource();
-        zigbeeGroup.bridgedDevice.addRequiredClusterServers(zigbeeGroup.bridgedDevice);
-        // Verify the device
+        zigbeeGroup.bridgedDevice.addRequiredClusterServers();
         if (!zigbeeGroup.bridgedDevice || !zigbeeGroup.verifyMutableDevice(zigbeeGroup.bridgedDevice))
             return zigbeeGroup;
-        // Log properties
         zigbeeGroup.logPropertyMap();
-        // Add command handlers
         if (isSwitch || isLight) {
             if (isSwitch && !isLight)
                 await zigbeeGroup.bridgedDevice.addFixedLabel('type', 'switch');
@@ -629,7 +439,6 @@ export class ZigbeeGroup extends ZigbeeEntity {
                 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}`);
-                // logEndpoint(zigbeeGroup.bridgedDevice!);
             });
             zigbeeGroup.bridgedDevice.addCommandHandler('on', async () => {
                 zigbeeGroup.log.debug(`Command on called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db}`);
@@ -721,7 +530,6 @@ export class ZigbeeGroup extends ZigbeeEntity {
             zigbeeGroup.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'systemMode', (newValue, oldValue) => {
                 zigbeeGroup.bridgedDevice?.log.info(`Thermostat systemMode changed from ${oldValue} to ${newValue}`);
                 if (oldValue !== newValue) {
-                    // Thermostat.SystemMode.Heat && newValue === Thermostat.SystemMode.Off
                     zigbeeGroup.bridgedDevice?.log.info(`Setting thermostat systemMode to ${newValue}`);
                     if (newValue === Thermostat.SystemMode.Off) {
                         zigbeeGroup.publishCommand('SystemMode', group.friendly_name, { system_mode: 'off' });
@@ -762,7 +570,6 @@ export class ZigbeeGroup extends ZigbeeEntity {
         return zigbeeGroup;
     }
 }
-// prettier-ignore
 export const z2ms = [
     { type: 'switch', name: 'state', property: 'state', deviceType: onOffSwitch, cluster: OnOff.Cluster.id, attribute: 'onOff', converter: (value) => { return value === 'ON' ? true : false; } },
     { type: 'switch', name: 'brightness', property: 'brightness', deviceType: dimmableSwitch, cluster: LevelControl.Cluster.id, attribute: 'currentLevel', converter: (value) => { return Math.max(1, Math.min(254, value)); } },
@@ -821,46 +628,22 @@ export const z2ms = [
     { 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; } },
 ];
-/**
- * Represents a Zigbee device entity.
- *
- * @class
- * @extends {ZigbeeEntity}
- */
 export class ZigbeeDevice extends ZigbeeEntity {
-    /**
-     * Represents a Zigbee device entity.
-     *
-     * @class
-     * @extends {ZigbeeEntity}
-     */
     constructor(platform, device) {
         super(platform, device);
     }
-    /**
-     * Creates a new ZigbeeDevice instance.
-     *
-     * @param {ZigbeePlatform} platform - The Zigbee platform instance.
-     * @param {BridgeDevice} device - The bridge device instance.
-     * @returns {Promise<ZigbeeDevice>} A promise that resolves to the created ZigbeeDevice instance.
-     *
-     * @remarks
-     * This method initializes a new ZigbeeDevice instance, sets up its properties, and configures the device
-     * based on the device definition and options. It also adds command handlers for the device.
-     */
     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);
         }
-        // Set Coordinator and dedicated routers
         if (device.friendly_name === 'Coordinator' || (device.model_id === 'ti.router' && device.manufacturer === 'TexasInstruments') || (device.model_id.startsWith('SLZB-') && device.manufacturer === 'SMLIGHT')) {
             zigbeeDevice.isRouter = true;
-            zigbeeDevice.bridgedDevice = await zigbeeDevice.createMutableDevice([doorLockDevice], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug" /* LogLevel.DEBUG */);
+            zigbeeDevice.bridgedDevice = new MatterbridgeEndpoint([doorLockDevice], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
             zigbeeDevice.addBridgedDeviceBasicInformation();
             zigbeeDevice.addPowerSource();
-            zigbeeDevice.bridgedDevice.addRequiredClusterServers(zigbeeDevice.bridgedDevice);
+            zigbeeDevice.bridgedDevice.addRequiredClusterServers();
             await zigbeeDevice.bridgedDevice.addFixedLabel('type', 'lock');
             zigbeeDevice.verifyMutableDevice(zigbeeDevice.bridgedDevice);
             zigbeeDevice.bridgedDevice.addCommandHandler('lockDoor', async () => {
@@ -875,7 +658,6 @@ export class ZigbeeDevice extends ZigbeeEntity {
             });
             return zigbeeDevice;
         }
-        // Get types and properties
         const types = [];
         const endpoints = [];
         const names = [];
@@ -889,7 +671,6 @@ export class ZigbeeDevice extends ZigbeeEntity {
         const values = [];
         device.definition?.exposes.forEach((expose) => {
             if (expose.features) {
-                // Specific features with type
                 expose.features?.forEach((feature) => {
                     if (expose.type === 'lock' && feature.name === 'state' && feature.property === 'child_lock')
                         feature.name = 'child_lock';
@@ -907,8 +688,6 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 });
             }
             else {
-                // Generic features without type
-                // Change voltage to battery_voltage for battery powered devices
                 if (device.power_source === 'Battery' && expose.name === 'voltage')
                     expose.name = 'battery_voltage';
                 if (device.power_source === 'Battery' && expose.property === 'voltage')
@@ -957,7 +736,6 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 types[index] = type === 'switch' || type === 'light' ? 'outlet' : type;
             });
         }
-        // Set the device entity select
         platform.selectEntity.set('last_seen', { name: 'last_seen', description: 'Last seen', icon: 'hub' });
         for (const [index, property] of properties.entries()) {
             zigbeeDevice.log.debug(`Device ${zigbeeDevice.en}${device.friendly_name}${db} adds select device ${device.ieee_address} (${device.friendly_name})`);
@@ -969,21 +747,10 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 platform.selectEntity.set(property, { name: property, description: descriptions[index], icon: 'hub' });
             platform.selectDevice.get(device.ieee_address)?.entities?.push({ name: property, description: descriptions[index], icon: 'hub' });
         }
-        // Set the global and devic based feature blacklist
         if (platform.featureBlackList)
             zigbeeDevice.ignoreFeatures = [...zigbeeDevice.ignoreFeatures, ...platform.featureBlackList];
         if (platform.deviceFeatureBlackList[device.friendly_name])
             zigbeeDevice.ignoreFeatures = [...zigbeeDevice.ignoreFeatures, ...platform.deviceFeatureBlackList[device.friendly_name]];
-        /*
-        zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} - types[${types.length}]: ${debugStringify(types)}`);
-        zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} - endpoints[${endpoints.length}]: ${debugStringify(endpoints)}`);
-        zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} - names[${names.length}]: ${debugStringify(names)}`);
-        zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} - properties[${properties.length}]: ${debugStringify(properties)}`);
-        zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} - categories[${categories.length}]: ${debugStringify(categories)}`);
-        zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} - descriptions[${descriptions.length}]: ${debugStringify(descriptions)}`);
-        zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} - labels[${labels.length}]: ${debugStringify(labels)}`);
-        zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} - units[${units.length}]: ${debugStringify(units)}`);
-        */
         for (const [index, name] of names.entries()) {
             if (platform.featureBlackList.includes(name) || platform.featureBlackList.includes(properties[index])) {
                 zigbeeDevice.log.debug(`Device ${zigbeeDevice.en}${device.friendly_name}${db} feature ${name} property ${properties[index]} is globally blacklisted`);
@@ -1012,9 +779,8 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${zb}${endpoint}${db} type: ${zb}${type}${db} property: ${zb}${name}${db} => deviceType: ${z2m.deviceType?.name} cluster: ${z2m.cluster} attribute: ${z2m.attribute}`);
                 zigbeeDevice.propertyMap.set(property, { name, type, endpoint, category, description, label, unit, value_min, value_max, values: value });
                 if (endpoint === '') {
-                    /* prettier-ignore */
                     if (!zigbeeDevice.mutableDevice.has(endpoint)) {
-                        zigbeeDevice.mutableDevice.set(endpoint, { tagList: [], deviceTypes: [z2m.deviceType], clusterServersIds: [...z2m.deviceType.requiredServerClusters, ClusterId(z2m.cluster)], clusterServersObjs: [], clusterClientsIds: [], clusterClientsObjs: [] });
+                        zigbeeDevice.mutableDevice.set(endpoint, { tagList: [], deviceTypes: [z2m.deviceType], clusterServersIds: [...z2m.deviceType.requiredServerClusters, ClusterId(z2m.cluster)], clusterServersOptions: [], clusterClientsIds: [], clusterClientsOptions: [] });
                     }
                     else {
                         zigbeeDevice.mutableDevice.get(endpoint)?.deviceTypes.push(z2m.deviceType);
@@ -1036,9 +802,8 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     if (endpoint === 'l6')
                         tagList.push({ mfgCode: null, namespaceId: NumberTag.Six.namespaceId, tag: NumberTag.Six.tag, label: 'endpoint ' + endpoint });
                     tagList.push({ mfgCode: null, namespaceId: SwitchesTag.Custom.namespaceId, tag: SwitchesTag.Custom.tag, label: 'endpoint ' + endpoint });
-                    /* prettier-ignore */
                     if (!zigbeeDevice.mutableDevice.has(endpoint)) {
-                        zigbeeDevice.mutableDevice.set(endpoint, { tagList, deviceTypes: [z2m.deviceType], clusterServersIds: [...z2m.deviceType.requiredServerClusters, ClusterId(z2m.cluster)], clusterServersObjs: [], clusterClientsIds: [], clusterClientsObjs: [] });
+                        zigbeeDevice.mutableDevice.set(endpoint, { tagList, deviceTypes: [z2m.deviceType], clusterServersIds: [...z2m.deviceType.requiredServerClusters, ClusterId(z2m.cluster)], clusterServersOptions: [], clusterClientsIds: [], clusterClientsOptions: [] });
                     }
                     else {
                         zigbeeDevice.mutableDevice.get(endpoint)?.deviceTypes.push(z2m.deviceType);
@@ -1050,16 +815,13 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 }
             }
             else {
-                // zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${zb}${endpoint}${db} type: ${zb}${type}${db} property: ${zb}${name}${db} => no mapping found`);
             }
-            // Map actions to switches
             if (name === 'action' && zigbeeDevice.actions.length) {
                 zigbeeDevice.log.info(`Device ${zigbeeDevice.ien}${device.friendly_name}${rs}${nf} has actions mapped to these switches on sub endpoints:`);
                 zigbeeDevice.log.info('   controller events      <=> zigbee2mqtt actions');
                 if (!zigbeeDevice.bridgedDevice)
-                    zigbeeDevice.bridgedDevice = await zigbeeDevice.createMutableDevice([bridgedNode], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug" /* LogLevel.DEBUG */);
+                    zigbeeDevice.bridgedDevice = new MatterbridgeEndpoint([bridgedNode], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
                 zigbeeDevice.hasEndpoints = true;
-                // Mapping actions
                 const switchMap = ['Single Press', 'Double Press', 'Long Press  '];
                 const triggerMap = ['Single', 'Double', 'Long'];
                 let count = 1;
@@ -1072,7 +834,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     }
                     const tagList = [];
                     tagList.push({ mfgCode: null, namespaceId: SwitchesTag.Custom.namespaceId, tag: SwitchesTag.Custom.tag, label: 'switch_' + count });
-                    zigbeeDevice.mutableDevice.set('switch_' + count, { tagList, deviceTypes: [genericSwitch], clusterServersIds: [...genericSwitch.requiredServerClusters], clusterServersObjs: [], clusterClientsIds: [], clusterClientsObjs: [] });
+                    zigbeeDevice.mutableDevice.set('switch_' + count, { tagList, deviceTypes: [genericSwitch], clusterServersIds: [...genericSwitch.requiredServerClusters], clusterServersOptions: [], clusterClientsIds: [], clusterClientsOptions: [] });
                 }
                 else {
                     for (let i = 0; i < zigbeeDevice.actions.length; i += 3) {
@@ -1084,7 +846,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                         }
                         const tagList = [];
                         tagList.push({ mfgCode: null, namespaceId: SwitchesTag.Custom.namespaceId, tag: SwitchesTag.Custom.tag, label: 'switch_' + count });
-                        zigbeeDevice.mutableDevice.set('switch_' + count, { tagList, deviceTypes: [genericSwitch], clusterServersIds: [...genericSwitch.requiredServerClusters], clusterServersObjs: [], clusterClientsIds: [], clusterClientsObjs: [] });
+                        zigbeeDevice.mutableDevice.set('switch_' + count, { tagList, deviceTypes: [genericSwitch], clusterServersIds: [...genericSwitch.requiredServerClusters], clusterServersOptions: [], clusterClientsIds: [], clusterClientsOptions: [] });
                         count++;
                     }
                 }
@@ -1092,19 +854,16 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     zigbeeDevice.composedType = 'button';
             }
         }
-        // Add battery properties
         if (device.power_source === 'Battery') {
             zigbeeDevice.propertyMap.set('battery', { name: 'battery', type: '', endpoint: '' });
             zigbeeDevice.propertyMap.set('battery_low', { name: 'battery_low', type: '', endpoint: '' });
             zigbeeDevice.propertyMap.set('battery_voltage', { name: 'battery_voltage', type: '', endpoint: '' });
         }
-        // Handle when the device has only child endpoints
         if (!zigbeeDevice.mutableDevice.has(''))
-            zigbeeDevice.mutableDevice.set('', { tagList: [], deviceTypes: [bridgedNode, powerSource], clusterServersIds: [], clusterServersObjs: [], clusterClientsIds: [], clusterClientsObjs: [] });
+            zigbeeDevice.mutableDevice.set('', { tagList: [], deviceTypes: [bridgedNode, powerSource], clusterServersIds: [], clusterServersOptions: [], clusterClientsIds: [], clusterClientsOptions: [] });
         const mainEndpoint = zigbeeDevice.mutableDevice.get('');
         if (!mainEndpoint)
             return zigbeeDevice;
-        // Remove duplicates and superset device Types on all endpoints
         for (const device of zigbeeDevice.mutableDevice.values()) {
             const deviceTypesMap = new Map();
             device.deviceTypes.forEach((deviceType) => {
@@ -1120,22 +879,28 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 deviceTypesMap.delete(onOffLight.code);
             if (deviceTypesMap.has(dimmableLight.code) && deviceTypesMap.has(colorTemperatureLight.code))
                 deviceTypesMap.delete(dimmableLight.code);
-            device.deviceTypes = Array.from(deviceTypesMap.values()); /* .sort((a, b) => b.code - a.code);*/
+            deviceTypesMap.delete(powerSource.code);
+            device.deviceTypes = Array.from(deviceTypesMap.values());
         }
-        // Create the mutable device for the main endpoint
-        zigbeeDevice.bridgedDevice = await zigbeeDevice.createMutableDevice(mainEndpoint.deviceTypes, { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug" /* LogLevel.DEBUG */);
-        // Configure BridgedDeviceBasicInformation cluster
-        mainEndpoint.clusterServersObjs.push(zigbeeDevice.getBridgedDeviceBasicInformation());
-        // Configure PowerSource cluster
-        mainEndpoint.clusterServersObjs.push(zigbeeDevice.getPowerSource());
-        // Configure ColorControlCluster
+        zigbeeDevice.bridgedDevice = new MatterbridgeEndpoint([...mainEndpoint.deviceTypes, bridgedNode, powerSource], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
+        zigbeeDevice.addBridgedDeviceBasicInformation();
+        zigbeeDevice.addPowerSource();
+        mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(PowerSource.Cluster.id), 1);
+        const options = require(PowerSourceBehavior.with(PowerSource.Feature.Wired), {
+            wiredCurrentType: PowerSource.WiredCurrentType.Ac,
+            description: 'AC Power',
+            status: PowerSource.PowerSourceStatus.Active,
+            order: 0,
+            endpointList: [],
+        });
+        mainEndpoint.clusterServersOptions.push(options);
         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')) {
-                mainEndpoint.clusterServersObjs.push(zigbeeDevice.bridgedDevice.getCtColorControlClusterServer());
+                zigbeeDevice.bridgedDevice.createCtColorControlClusterServer();
+                mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(ColorControl.Cluster.id), 1);
             }
         }
-        // Configure ThermostatCluster: Auto or Heating only or Cooling only. Set also min and max if available
         if (mainEndpoint.clusterServersIds.includes(Thermostat.Cluster.id)) {
             const heat = zigbeeDevice.propertyMap.get('occupied_heating_setpoint') || zigbeeDevice.propertyMap.get('current_heating_setpoint');
             const cool = zigbeeDevice.propertyMap.get('occupied_cooling_setpoint') || zigbeeDevice.propertyMap.get('current_cooling_setpoint');
@@ -1146,80 +911,65 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} Thermostat cluster with heating ${CYAN}${heat ? 'supported' : 'not supported'}${db} cooling ${CYAN}${cool ? 'supported' : 'not supported'}${db} ` +
                 `minHeating ${CYAN}${minHeating}${db} maxHeating ${CYAN}${maxHeating}${db} minCooling ${CYAN}${minCooling}${db} maxCooling ${CYAN}${maxCooling}${db}`);
             if (heat && !cool) {
-                zigbeeDevice.propertyMap.delete('running_state'); // Remove running_state if only heating is supported cause it's not supported by the cluster without AutoMode
-                mainEndpoint.clusterServersObjs.push(zigbeeDevice.bridgedDevice.getDefaultHeatingThermostatClusterServer(undefined, undefined, minHeating, maxHeating));
+                zigbeeDevice.propertyMap.delete('running_state');
+                zigbeeDevice.bridgedDevice.createDefaultHeatingThermostatClusterServer(undefined, undefined, minHeating, maxHeating);
+                mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(Thermostat.Cluster.id), 1);
             }
             else if (!heat && cool) {
-                zigbeeDevice.propertyMap.delete('running_state'); // Remove running_state if only cooling is supported cause it's not supported by the cluster without AutoMode
-                mainEndpoint.clusterServersObjs.push(zigbeeDevice.bridgedDevice.getDefaultCoolingThermostatClusterServer(undefined, undefined, minCooling, maxCooling));
+                zigbeeDevice.propertyMap.delete('running_state');
+                zigbeeDevice.bridgedDevice.createDefaultCoolingThermostatClusterServer(undefined, undefined, minCooling, maxCooling);
+                mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(Thermostat.Cluster.id), 1);
             }
             else if (heat && cool) {
-                mainEndpoint.clusterServersObjs.push(zigbeeDevice.bridgedDevice.getDefaultThermostatClusterServer(undefined, undefined, undefined, undefined, minHeating, maxHeating, minCooling, maxCooling));
+                zigbeeDevice.bridgedDevice.createDefaultThermostatClusterServer(undefined, undefined, undefined, undefined, minHeating, maxHeating, minCooling, maxCooling);
+                mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(Thermostat.Cluster.id), 1);
             }
         }
-        // Filter out duplicate clusters and clusters objects
         for (const [endpoint, device] of zigbeeDevice.mutableDevice) {
-            // Filter out duplicate server clusters and server clusters objects. Remove the cluster server id when a cluster server object is present.
-            const deviceClusterServersMap = new Map();
+            const deviceClusterServersIdMap = new Map();
             device.clusterServersIds.forEach((clusterServer) => {
-                deviceClusterServersMap.set(clusterServer, clusterServer);
+                deviceClusterServersIdMap.set(clusterServer, clusterServer);
             });
             const deviceClusterServersObjMap = new Map();
-            device.clusterServersObjs.forEach((clusterServerObj) => {
-                deviceClusterServersMap.delete(clusterServerObj.id);
-                deviceClusterServersObjMap.set(clusterServerObj.id, clusterServerObj);
+            device.clusterServersOptions.forEach((clusterServer) => {
+                deviceClusterServersIdMap.delete(clusterServer.clusterId);
+                deviceClusterServersObjMap.set(clusterServer.clusterId, clusterServer);
             });
-            device.clusterServersIds = Array.from(deviceClusterServersMap.values());
-            device.clusterServersObjs = Array.from(deviceClusterServersObjMap.values());
-            // Filter out duplicate client clusters and client clusters objects. Remove the cluster client id when a cluster client object is present.
-            const deviceClusterClientsMap = new Map();
+            device.clusterServersIds = Array.from(deviceClusterServersIdMap.values());
+            device.clusterServersOptions = Array.from(deviceClusterServersObjMap.values());
+            const deviceClusterClientsIdMap = new Map();
             device.clusterClientsIds.forEach((clusterClient) => {
-                deviceClusterClientsMap.set(clusterClient, clusterClient);
+                deviceClusterClientsIdMap.set(clusterClient, clusterClient);
             });
             const deviceClusterClientsObjMap = new Map();
-            device.clusterClientsObjs.forEach((clusterClientObj) => {
-                deviceClusterClientsMap.delete(clusterClientObj.id);
-                deviceClusterClientsObjMap.set(clusterClientObj.id, clusterClientObj);
+            device.clusterClientsOptions.forEach((clusterClient) => {
+                deviceClusterClientsIdMap.delete(clusterClient.clusterId);
+                deviceClusterClientsObjMap.set(clusterClient.clusterId, clusterClient);
             });
-            device.clusterClientsIds = Array.from(deviceClusterClientsMap.values());
-            device.clusterClientsObjs = Array.from(deviceClusterClientsObjMap.values());
+            device.clusterClientsIds = Array.from(deviceClusterClientsIdMap.values());
+            device.clusterClientsOptions = Array.from(deviceClusterClientsObjMap.values());
             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)}`);
         }
-        // Add the cluster objects to the main endpoint
-        mainEndpoint.clusterServersObjs.forEach((clusterServerObj) => {
-            zigbeeDevice.bridgedDevice?.addClusterServer(clusterServerObj);
-        });
-        // Add the cluster ids to the main endpoint
-        zigbeeDevice.bridgedDevice.addClusterServerFromList(zigbeeDevice.bridgedDevice, mainEndpoint.clusterServersIds);
-        zigbeeDevice.bridgedDevice.addRequiredClusterServers(zigbeeDevice.bridgedDevice);
-        // Add the Fixed Label cluster to the main endpoint
+        zigbeeDevice.bridgedDevice.addClusterServers(mainEndpoint.clusterServersIds);
+        zigbeeDevice.bridgedDevice.addRequiredClusterServers();
         if (zigbeeDevice.composedType !== '')
             await zigbeeDevice.bridgedDevice.addFixedLabel('composed', zigbeeDevice.composedType);
-        // Create the child endpoints
         for (const [endpoint, device] of zigbeeDevice.mutableDevice) {
             if (endpoint === '')
                 continue;
-            const child = zigbeeDevice.bridgedDevice?.addChildDeviceTypeWithClusterServer(endpoint, device.deviceTypes, device.clusterServersIds, { tagList: device.tagList }, zigbeeDevice.log.logLevel === "debug" /* LogLevel.DEBUG */);
-            device.clusterServersObjs.forEach((clusterServerObj) => {
-                child.addClusterServer(clusterServerObj);
-            });
+            zigbeeDevice.bridgedDevice?.addChildDeviceTypeWithClusterServer(endpoint, device.deviceTypes, device.clusterServersIds, { tagList: device.tagList }, zigbeeDevice.log.logLevel === "debug");
         }
-        // Verify the device
         if (!zigbeeDevice.verifyMutableDevice(zigbeeDevice.bridgedDevice))
             return zigbeeDevice;
-        // Clear the mutable device from memory
         zigbeeDevice.mutableDevice.clear();
-        // Log properties
         zigbeeDevice.logPropertyMap();
-        // Add command handlers
         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} `);
-            // logEndpoint(zigbeeDevice.bridgedDevice!);
         });
-        if (zigbeeDevice.bridgedDevice.getClusterServerById(OnOffCluster.id) || zigbeeDevice.hasEndpoints) {
+        if (zigbeeDevice.bridgedDevice.hasClusterServer(OnOffCluster.id) || zigbeeDevice.hasEndpoints) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
-                if (zigbeeDevice.platform.matterbridge.edge && child.hasClusterServer(OnOffCluster)) {
+                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}`);
                         const payload = {};
@@ -1271,9 +1021,9 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 zigbeeDevice.publishCommand('toggle', device.friendly_name, payload);
             });
         }
-        if (zigbeeDevice.bridgedDevice.getClusterServerById(LevelControlCluster.id) || zigbeeDevice.hasEndpoints) {
+        if (zigbeeDevice.bridgedDevice.hasClusterServer(LevelControlCluster.id) || zigbeeDevice.hasEndpoints) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
-                if (zigbeeDevice.platform.matterbridge.edge && child.hasClusterServer(LevelControlCluster)) {
+                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}`);
                         const payload = {};
@@ -1317,7 +1067,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 zigbeeDevice.publishCommand('moveToLevelWithOnOff', device.friendly_name, payload);
             });
         }
-        if (zigbeeDevice.bridgedDevice.getClusterServerById(ColorControlCluster.id) && zigbeeDevice.bridgedDevice.getClusterServer(ColorControlCluster)?.isAttributeSupportedByName('colorTemperatureMireds')) {
+        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'colorTemperatureMireds')) {
             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);
@@ -1327,7 +1077,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 zigbeeDevice.publishCommand('moveToColorTemperature', device.friendly_name, payload);
             });
         }
-        if (zigbeeDevice.bridgedDevice.getClusterServerById(ColorControlCluster.id) && zigbeeDevice.bridgedDevice.getClusterServer(ColorControlCluster)?.isAttributeSupportedByName('currentX')) {
+        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'currentX')) {
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToColor', async ({ request }) => {
                 zigbeeDevice.log.debug(`Command moveToColor called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request: X: ${request.colorX} Y: ${request.colorY}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentXAndCurrentY, zigbeeDevice.log);
@@ -1337,7 +1087,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 zigbeeDevice.publishCommand('moveToColor', device.friendly_name, payload);
             });
         }
-        if (zigbeeDevice.bridgedDevice.getClusterServerById(ColorControlCluster.id) && zigbeeDevice.bridgedDevice.getClusterServer(ColorControlCluster)?.isAttributeSupportedByName('currentHue')) {
+        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'currentHue')) {
             let lastRequestedHue = 0;
             let lastRequestedSaturation = 0;
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToHue', async ({ request }) => {
@@ -1376,7 +1126,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 zigbeeDevice.publishCommand('moveToHueAndSaturation', device.friendly_name, payload);
             });
         }
-        if (zigbeeDevice.bridgedDevice.getClusterServerById(WindowCoveringCluster.id)) {
+        if (zigbeeDevice.bridgedDevice.hasClusterServer(WindowCoveringCluster.id)) {
             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'))
@@ -1407,7 +1157,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 zigbeeDevice.publishCommand('goToLiftPercentage', device.friendly_name, { position: liftPercent100thsValue / 100 });
             });
         }
-        if (zigbeeDevice.bridgedDevice.getClusterServerById(DoorLockCluster.id)) {
+        if (zigbeeDevice.bridgedDevice.hasClusterServer(DoorLockCluster.id)) {
             zigbeeDevice.bridgedDevice.addCommandHandler('lockDoor', async ({ request: request }) => {
                 zigbeeDevice.log.debug(`Command lockDoor called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db}`, request);
                 await zigbeeDevice.bridgedDevice?.setAttribute(DoorLockCluster.id, 'lockState', DoorLock.LockState.Locked, zigbeeDevice.log);
@@ -1419,7 +1169,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                 zigbeeDevice.publishCommand('unlockDoor', device.friendly_name, { state: 'UNLOCK' });
             });
         }
-        if (zigbeeDevice.bridgedDevice.getClusterServerById(ThermostatCluster.id)) {
+        if (zigbeeDevice.bridgedDevice.hasClusterServer(ThermostatCluster.id)) {
             zigbeeDevice.bridgedDevice.addCommandHandler('setpointRaiseLower', async ({ request: request }) => {
                 zigbeeDevice.log.debug(`Command setpointRaiseLower called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request:`, request);
                 if (request.mode === Thermostat.SetpointRaiseLowerMode.Heat || request.mode === Thermostat.SetpointRaiseLowerMode.Both) {
@@ -1447,44 +1197,40 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     }
                 }
             });
-            const thermostat = zigbeeDevice.bridgedDevice.getClusterServerById(ThermostatCluster.id);
-            if (thermostat) {
-                zigbeeDevice.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'systemMode', async (value) => {
-                    zigbeeDevice.log.debug(`Subscribe systemMode called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} with:`, value);
-                    const system_mode = value === Thermostat.SystemMode.Off ? 'off' : value === Thermostat.SystemMode.Heat ? 'heat' : 'cool';
-                    zigbeeDevice.publishCommand('SystemMode', device.friendly_name, { system_mode });
+            zigbeeDevice.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'systemMode', async (value) => {
+                zigbeeDevice.log.debug(`Subscribe systemMode called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} with:`, value);
+                const system_mode = value === Thermostat.SystemMode.Off ? 'off' : value === Thermostat.SystemMode.Heat ? 'heat' : 'cool';
+                zigbeeDevice.publishCommand('SystemMode', device.friendly_name, { system_mode });
+                zigbeeDevice.noUpdate = true;
+                zigbeeDevice.thermostatTimeout = setTimeout(() => {
+                    zigbeeDevice.noUpdate = false;
+                }, 5 * 1000);
+            }, zigbeeDevice.log);
+            if (zigbeeDevice.bridgedDevice.hasAttributeServer(ThermostatCluster.id, 'occupiedHeatingSetpoint'))
+                zigbeeDevice.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'occupiedHeatingSetpoint', async (value) => {
+                    zigbeeDevice.log.debug(`Subscribe occupiedHeatingSetpoint called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} with:`, value);
+                    if (zigbeeDevice.propertyMap.has('current_heating_setpoint'))
+                        zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { current_heating_setpoint: Math.round(value / 100) });
+                    else if (zigbeeDevice.propertyMap.has('occupied_heating_setpoint'))
+                        zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { occupied_heating_setpoint: Math.round(value / 100) });
+                    zigbeeDevice.noUpdate = true;
+                    zigbeeDevice.thermostatTimeout = setTimeout(() => {
+                        zigbeeDevice.noUpdate = false;
+                    }, 5 * 1000);
+                }, zigbeeDevice.log);
+            if (zigbeeDevice.bridgedDevice.hasAttributeServer(ThermostatCluster.id, 'occupiedCoolingSetpoint'))
+                zigbeeDevice.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'occupiedCoolingSetpoint', async (value) => {
+                    zigbeeDevice.log.debug(`Subscribe occupiedCoolingSetpoint called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} with:`, value);
+                    if (zigbeeDevice.propertyMap.has('current_cooling_setpoint'))
+                        zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { current_cooling_setpoint: Math.round(value / 100) });
+                    else if (zigbeeDevice.propertyMap.has('occupied_cooling_setpoint'))
+                        zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { occupied_cooling_setpoint: Math.round(value / 100) });
                     zigbeeDevice.noUpdate = true;
                     zigbeeDevice.thermostatTimeout = setTimeout(() => {
                         zigbeeDevice.noUpdate = false;
                     }, 5 * 1000);
                 }, zigbeeDevice.log);
-                if (thermostat.attributes.occupiedHeatingSetpoint)
-                    zigbeeDevice.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'occupiedHeatingSetpoint', async (value) => {
-                        zigbeeDevice.log.debug(`Subscribe occupiedHeatingSetpoint called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} with:`, value);
-                        if (zigbeeDevice.propertyMap.has('current_heating_setpoint'))
-                            zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { current_heating_setpoint: Math.round(value / 100) });
-                        else if (zigbeeDevice.propertyMap.has('occupied_heating_setpoint'))
-                            zigbeeDevice.publishCommand('OccupiedHeatingSetpoint', device.friendly_name, { occupied_heating_setpoint: Math.round(value / 100) });
-                        zigbeeDevice.noUpdate = true;
-                        zigbeeDevice.thermostatTimeout = setTimeout(() => {
-                            zigbeeDevice.noUpdate = false;
-                        }, 5 * 1000);
-                    }, zigbeeDevice.log);
-                if (thermostat.attributes.occupiedCoolingSetpoint)
-                    zigbeeDevice.bridgedDevice.subscribeAttribute(ThermostatCluster.id, 'occupiedCoolingSetpoint', async (value) => {
-                        zigbeeDevice.log.debug(`Subscribe occupiedCoolingSetpoint called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} with:`, value);
-                        if (zigbeeDevice.propertyMap.has('current_cooling_setpoint'))
-                            zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { current_cooling_setpoint: Math.round(value / 100) });
-                        else if (zigbeeDevice.propertyMap.has('occupied_cooling_setpoint'))
-                            zigbeeDevice.publishCommand('OccupiedCoolingSetpoint', device.friendly_name, { occupied_cooling_setpoint: Math.round(value / 100) });
-                        zigbeeDevice.noUpdate = true;
-                        zigbeeDevice.thermostatTimeout = setTimeout(() => {
-                            zigbeeDevice.noUpdate = false;
-                        }, 5 * 1000);
-                    }, zigbeeDevice.log);
-            }
         }
         return zigbeeDevice;
     }
 }
-//# sourceMappingURL=entity.js.map