matterbridge-zigbee2mqtt 2.3.0-dev.1 → 2.3.0-dev.2

package/dist/entity.js

@@ -1,37 +1,9 @@
-/**
- * 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 { 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 * 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}
- */
 export class ZigbeeEntity extends EventEmitter {
     log;
     serial = '';
@@ -51,7 +23,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 +30,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 +47,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,24 +76,19 @@ 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';
-                // Modify illuminance and illuminance_lux
                 if (key === 'illuminance' && this.isDevice && this.device && this.device.definition && ['RTCGQ14LM'].includes(this.device.definition.model)) {
                     key = 'illuminance_lux';
                 }
                 if (key === 'illuminance' && typeof value === 'number' && this.isDevice && this.device && this.device.definition && ['ZG-204ZL', 'ZG-205Z/A'].includes(this.device.definition.model)) {
                     value = value * 10;
                 }
-                // 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} ` +
@@ -152,11 +108,9 @@ 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);
@@ -164,9 +118,6 @@ export class ZigbeeEntity extends EventEmitter {
                     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);
                 }
@@ -187,12 +138,10 @@ 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, 'colorTemperatureMireds', Math.max(147, Math.min(500, typeof value === 'number' ? value : 0)));
                     this.updateAttributeIfChanged(this.bridgedDevice, undefined, ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds);
                 }
-                // ColorControl currentHue, currentSaturation and colorMode
                 if (key === 'color' && 'color_mode' in payload && payload['color_mode'] === 'xy') {
                     const { x, y } = value;
                     const hsl = color.xyToHsl(x, y);
@@ -220,13 +169,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);
@@ -235,22 +177,6 @@ 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));
@@ -263,7 +189,6 @@ export class ZigbeeEntity extends EventEmitter {
     getBridgedDeviceBasicInformation() {
         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');
@@ -281,7 +206,6 @@ export class ZigbeeEntity extends EventEmitter {
     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());
         return this.bridgedDevice;
@@ -302,26 +226,13 @@ export class ZigbeeEntity extends EventEmitter {
     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());
         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)) {
@@ -330,7 +241,6 @@ export class ZigbeeEntity extends EventEmitter {
                 }
             }
         }
-        // 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) {
@@ -343,17 +253,6 @@ 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)) {
             this.log.info(`Configuring ${this.bridgedDevice?.deviceName} WindowCovering cluster`);
@@ -370,22 +269,6 @@ 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;
@@ -424,18 +307,6 @@ export class ZigbeeEntity extends EventEmitter {
             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')) {
@@ -445,16 +316,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} ` +
@@ -462,33 +324,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) {
@@ -508,23 +347,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 = await zigbeeGroup.createMutableDevice([onOffSwitch], { 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';
@@ -554,7 +389,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}`);
                     }
                 });
@@ -600,17 +434,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 = await zigbeeGroup.createMutableDevice([deviceType], { uniqueStorageKey: group.friendly_name }, zigbeeGroup.log.logLevel === "debug");
         }
         zigbeeGroup.addBridgedDeviceBasicInformation();
         zigbeeGroup.addPowerSource();
         zigbeeGroup.bridgedDevice.addRequiredClusterServers(zigbeeGroup.bridgedDevice);
-        // Verify the device
         if (!zigbeeGroup.bridgedDevice || !zigbeeGroup.verifyMutableDevice(zigbeeGroup.bridgedDevice))
             return zigbeeGroup;
-        // Log properties
         zigbeeGroup.logPropertyMap();
-        // Add command handlers
         if (isSwitch || isLight) {
             if (isSwitch)
                 await zigbeeGroup.bridgedDevice.addFixedLabel('type', 'switch');
@@ -618,7 +449,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}`);
@@ -710,7 +540,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' });
@@ -751,7 +580,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(0, Math.min(254, value)); } },
@@ -811,43 +639,19 @@ 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 = await zigbeeDevice.createMutableDevice([doorLockDevice], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
             zigbeeDevice.addBridgedDeviceBasicInformation();
             zigbeeDevice.addPowerSource();
             zigbeeDevice.bridgedDevice.addRequiredClusterServers(zigbeeDevice.bridgedDevice);
@@ -865,7 +669,6 @@ export class ZigbeeDevice extends ZigbeeEntity {
             });
             return zigbeeDevice;
         }
-        // Get types and properties
         const types = [];
         const endpoints = [];
         const names = [];
@@ -879,7 +682,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';
@@ -897,17 +699,10 @@ 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')
                     expose.property = 'battery_voltage';
-                // Fix illuminance and illuminance_lux for light sensors:
-                // illuminance is raw value (use like it is)
-                // illuminance_lux is in lux (convert with log10)
-                // illuminance has description "Raw measured illuminance"
-                // illuminance_lux has description "Measured illuminance in lux"
                 if (expose.description === 'Raw measured illuminance') {
                     expose.name = 'illuminance';
                     expose.property = 'illuminance';
@@ -968,16 +763,6 @@ export class ZigbeeDevice extends ZigbeeEntity {
             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)) {
                 zigbeeDevice.log.debug(`Device ${zigbeeDevice.en}${device.friendly_name}${db} feature ${name} is globally blacklisted`);
@@ -1006,7 +791,6 @@ 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: [] });
                     }
@@ -1030,7 +814,6 @@ 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: [] });
                     }
@@ -1044,16 +827,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 = await zigbeeDevice.createMutableDevice([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;
@@ -1086,7 +866,6 @@ 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: '' });
@@ -1097,7 +876,6 @@ export class ZigbeeDevice extends ZigbeeEntity {
         const mainEndpoint = zigbeeDevice.mutableDevice.get('');
         if (!mainEndpoint)
             return zigbeeDevice;
-        // Remove superset device Types and order them
         for (const device of zigbeeDevice.mutableDevice.values()) {
             const deviceTypesMap = new Map();
             device.deviceTypes.forEach((deviceType) => {
@@ -1113,20 +891,15 @@ 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);*/
+            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
+        zigbeeDevice.bridgedDevice = await zigbeeDevice.createMutableDevice(mainEndpoint.deviceTypes, { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
         mainEndpoint.clusterServersObjs.push(zigbeeDevice.getBridgedDeviceBasicInformation());
-        // Configure PowerSource cluster
         mainEndpoint.clusterServersObjs.push(zigbeeDevice.getPowerSource());
-        // Configure ColorControlCluster
         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')}`);
             zigbeeDevice.bridgedDevice.configureColorControlCluster(names.includes('color_hs') || names.includes('color_xy'), false, names.includes('color_temp'));
         }
-        // Configure ThermostatCluster
         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');
@@ -1137,20 +910,18 @@ 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
+                zigbeeDevice.propertyMap.delete('running_state');
                 mainEndpoint.clusterServersObjs.push(zigbeeDevice.bridgedDevice.getDefaultHeatingThermostatClusterServer(undefined, undefined, minHeating, maxHeating));
             }
             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
+                zigbeeDevice.propertyMap.delete('running_state');
                 mainEndpoint.clusterServersObjs.push(zigbeeDevice.bridgedDevice.getDefaultCoolingThermostatClusterServer(undefined, undefined, minCooling, maxCooling));
             }
             else if (heat && cool) {
                 mainEndpoint.clusterServersObjs.push(zigbeeDevice.bridgedDevice.getDefaultThermostatClusterServer(undefined, undefined, undefined, undefined, minHeating, maxHeating, minCooling, maxCooling));
             }
         }
-        // Filter out duplicate server clusters and server clusters objects
         for (const [endpoint, device] of zigbeeDevice.mutableDevice) {
-            // Filter out duplicate server clusters and server clusters objects
             const deviceClusterServersMap = new Map();
             device.clusterServersIds.forEach((clusterServer) => {
                 deviceClusterServersMap.set(clusterServer, clusterServer);
@@ -1162,7 +933,6 @@ export class ZigbeeDevice extends ZigbeeEntity {
             });
             device.clusterServersIds = Array.from(deviceClusterServersMap.values());
             device.clusterServersObjs = Array.from(deviceClusterServersObjMap.values());
-            // Filter out duplicate client clusters and client clusters objects
             const deviceClusterClientsMap = new Map();
             device.clusterClientsIds.forEach((clusterClient) => {
                 deviceClusterClientsMap.set(clusterClient, clusterClient);
@@ -1177,7 +947,6 @@ 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)}`);
         }
-        // Add the clusters to the main endpoint
         mainEndpoint.clusterServersObjs.forEach((clusterServerObj) => {
             zigbeeDevice.bridgedDevice?.addClusterServer(clusterServerObj);
         });
@@ -1185,24 +954,19 @@ export class ZigbeeDevice extends ZigbeeEntity {
         zigbeeDevice.bridgedDevice.addRequiredClusterServers(zigbeeDevice.bridgedDevice);
         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 */);
+            const child = zigbeeDevice.bridgedDevice?.addChildDeviceTypeWithClusterServer(endpoint, device.deviceTypes, device.clusterServersIds, { tagList: device.tagList }, zigbeeDevice.log.logLevel === "debug");
             device.clusterServersObjs.forEach((clusterServerObj) => {
                 child.addClusterServer(clusterServerObj);
             });
         }
-        // Verify the device
         if (!zigbeeDevice.verifyMutableDevice(zigbeeDevice.bridgedDevice))
             return zigbeeDevice;
-        // 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) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
@@ -1464,4 +1228,3 @@ export class ZigbeeDevice extends ZigbeeEntity {
         return zigbeeDevice;
     }
 }
-//# sourceMappingURL=entity.js.map