matterbridge 1.5.9 → 1.6.0

package/dist/matterbridgeEndpoint.js

@@ -0,0 +1,2196 @@
+/**
+ * This file contains the class MatterbridgeEndpoint that extends the Endpoint class from the Matter.js library.
+ *
+ * @file matterbridgeEndpoint.ts
+ * @author Luca Liguori
+ * @date 2024-10-01
+ * @version 1.0.0
+ *
+ * Copyright 2024 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. *
+ */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// New API imports
+import { Endpoint } from '@project-chip/matter.js/endpoint';
+import { MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
+import { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
+import { DescriptorServer } from '@project-chip/matter.js/behavior/definitions/descriptor';
+import { IdentifyServer } from '@project-chip/matter.js/behavior/definitions/identify';
+import { GroupsServer } from '@project-chip/matter.js/behavior/definitions/groups';
+// import { ScenesServer, ScenesBehavior } from '@project-chip/matter.js/behavior/definitions/scenes';
+import { OnOffServer } from '@project-chip/matter.js/behavior/definitions/on-off';
+import { TemperatureMeasurementServer } from '@project-chip/matter.js/behavior/definitions/temperature-measurement';
+import { RelativeHumidityMeasurementServer } from '@project-chip/matter.js/behavior/definitions/relative-humidity-measurement';
+import { PressureMeasurementServer } from '@project-chip/matter.js/behavior/definitions/pressure-measurement';
+import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behavior/definitions/bridged-device-basic-information';
+import { AirQuality, AirQualityCluster, BasicInformationCluster, BooleanState, BooleanStateCluster, BooleanStateConfiguration, BooleanStateConfigurationCluster, BridgedDeviceBasicInformation, BridgedDeviceBasicInformationCluster, CarbonDioxideConcentrationMeasurement, CarbonDioxideConcentrationMeasurementCluster, CarbonMonoxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurementCluster, ClusterServer, ColorControl, ColorControlCluster, ConcentrationMeasurement, DoorLock, DoorLockCluster, ElectricalEnergyMeasurement, ElectricalEnergyMeasurementCluster, ElectricalPowerMeasurement, ElectricalPowerMeasurementCluster, FanControl, FanControlCluster, FlowMeasurement, FlowMeasurementCluster, FormaldehydeConcentrationMeasurement, FormaldehydeConcentrationMeasurementCluster, Groups, GroupsCluster, GroupsClusterHandler, Identify, IdentifyCluster, IlluminanceMeasurement, IlluminanceMeasurementCluster, LevelControl, LevelControlCluster, MeasurementType, ModeSelectCluster, NitrogenDioxideConcentrationMeasurement, NitrogenDioxideConcentrationMeasurementCluster, OccupancySensing, OccupancySensingCluster, OnOff, OnOffCluster, OzoneConcentrationMeasurement, OzoneConcentrationMeasurementCluster, Pm10ConcentrationMeasurement, Pm10ConcentrationMeasurementCluster, Pm1ConcentrationMeasurement, Pm1ConcentrationMeasurementCluster, Pm25ConcentrationMeasurement, Pm25ConcentrationMeasurementCluster, PowerSource, PowerSourceCluster, PowerSourceConfigurationCluster, PowerTopology, PowerTopologyCluster, PressureMeasurement, PressureMeasurementCluster, RadonConcentrationMeasurement, RadonConcentrationMeasurementCluster, RelativeHumidityMeasurement, RelativeHumidityMeasurementCluster, SmokeCoAlarm, SmokeCoAlarmCluster, Switch, SwitchCluster, TemperatureMeasurement, TemperatureMeasurementCluster, Thermostat, ThermostatCluster, ThreadNetworkDiagnostics, ThreadNetworkDiagnosticsCluster, TimeSynchronization, TimeSynchronizationCluster, TotalVolatileOrganicCompoundsConcentrationMeasurement, TotalVolatileOrganicCompoundsConcentrationMeasurementCluster, WindowCovering, WindowCoveringCluster, getClusterNameById, } from '@project-chip/matter-node.js/cluster';
+import { NamedHandler } from '@project-chip/matter-node.js/util';
+import { EndpointNumber, VendorId } from '@project-chip/matter-node.js/datatype';
+// Matterbridge imports
+import { AnsiLogger, YELLOW, db, debugStringify, er, hk, or, rs, zb } from 'node-ansi-logger';
+import { createHash } from 'crypto';
+import { Specification } from '@project-chip/matter-node.js/model';
+import { LevelControlServer } from '@project-chip/matter.js/behaviors/level-control';
+import { ColorControlServer } from '@project-chip/matter.js/behaviors/color-control';
+import { FlowMeasurementServer } from '@project-chip/matter.js/behaviors/flow-measurement';
+import { DoorLockServer } from '@project-chip/matter.js/behaviors/door-lock';
+import { ThermostatServer } from '@project-chip/matter.js/behaviors/thermostat';
+import { WindowCoveringServer } from '@project-chip/matter.js/behaviors/window-covering';
+import { FanControlServer } from '@project-chip/matter.js/behaviors/fan-control';
+import { TimeSynchronizationServer } from '@project-chip/matter.js/behaviors/time-synchronization';
+import { IlluminanceMeasurementServer } from '@project-chip/matter.js/behaviors/illuminance-measurement';
+import { BooleanStateServer } from '@project-chip/matter.js/behaviors/boolean-state';
+import { BooleanStateConfigurationServer } from '@project-chip/matter.js/behaviors/boolean-state-configuration';
+import { OccupancySensingServer } from '@project-chip/matter.js/behaviors/occupancy-sensing';
+export class MatterbridgeEndpoint extends Endpoint {
+    static bridgeMode = '';
+    log;
+    serialNumber = undefined;
+    deviceName = undefined;
+    uniqueId = undefined;
+    // Maps matter deviceTypes and endpoints
+    deviceTypes = new Map();
+    clusterServers = new Map();
+    clusterClients = new Map();
+    commandHandler = new NamedHandler();
+    /**
+     * Represents a MatterbridgeEndpoint device.
+     * @constructor
+     * @param {DeviceTypeDefinition} definition - The definition of the device.
+     * @param {EndpointOptions} [options={}] - The options for the device.
+     */
+    constructor(definition, options = {}) {
+        // Convert the DeviceTypeDefinition to a EndpointType.Options
+        const deviceTypeDefinitionV8 = {
+            name: definition.name.replace('-', '_'),
+            deviceType: definition.code,
+            deviceRevision: definition.revision,
+            deviceClass: definition.deviceClass,
+            requirements: {
+                server: {
+                    mandatory: SupportedBehaviors(...MatterbridgeEndpoint.getBehaviourTypesFromClusterServerIds(definition.requiredServerClusters)),
+                    optional: SupportedBehaviors(...MatterbridgeEndpoint.getBehaviourTypesFromClusterServerIds(definition.optionalServerClusters)),
+                },
+                client: {
+                    mandatory: SupportedBehaviors(...MatterbridgeEndpoint.getBehaviourTypesFromClusterClientIds(definition.requiredClientClusters)),
+                    optional: SupportedBehaviors(...MatterbridgeEndpoint.getBehaviourTypesFromClusterClientIds(definition.optionalClientClusters)),
+                },
+            },
+            behaviors: SupportedBehaviors(...MatterbridgeEndpoint.getBehaviourTypesFromClusterServerIds(definition.requiredServerClusters)),
+        };
+        const endpointV8 = MutableEndpoint(deviceTypeDefinitionV8);
+        const optionsV8 = {
+            id: options.uniqueStorageKey,
+        };
+        super(endpointV8, optionsV8);
+        this.log = new AnsiLogger({ logName: 'MatterbridgeDevice', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: true });
+        this.deviceTypes.set(definition.code, definition);
+    }
+    static getBehaviourTypesFromClusterServerIds(clusterServerList) {
+        // Map Server ClusterId to Behavior.Type
+        const behaviorTypes = [];
+        clusterServerList.forEach((clusterId) => {
+            behaviorTypes.push(MatterbridgeEndpoint.getBehaviourTypeFromClusterServerId(clusterId));
+        });
+        return behaviorTypes;
+    }
+    static getBehaviourTypesFromClusterClientIds(clusterClientList) {
+        // Map Client ClusterId to Behavior.Type
+        const behaviorTypes = [];
+        clusterClientList.forEach((clusterId) => {
+            // behaviorTypes.push(MatterbridgeEndpoint.getBehaviourTypeFromClusterClientId(clusterId));
+        });
+        return behaviorTypes;
+    }
+    static getBehaviourTypeFromClusterServerId(clusterId) {
+        // Map ClusterId to Behavior.Type
+        if (clusterId === Identify.Cluster.id)
+            return IdentifyServer;
+        if (clusterId === Groups.Cluster.id)
+            return GroupsServer;
+        // if (clusterId === Scenes.Cluster.id) return ScenesServer;
+        if (clusterId === OnOff.Cluster.id)
+            return OnOffServer;
+        if (clusterId === LevelControl.Cluster.id)
+            return LevelControlServer;
+        if (clusterId === ColorControl.Cluster.id)
+            return ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature);
+        if (clusterId === DoorLock.Cluster.id)
+            return DoorLockServer;
+        if (clusterId === Thermostat.Cluster.id)
+            return ThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode);
+        if (clusterId === TimeSynchronization.Cluster.id)
+            return TimeSynchronizationServer.with(TimeSynchronization.Feature.TimeZone);
+        if (clusterId === WindowCovering.Cluster.id)
+            return WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift);
+        if (clusterId === FanControl.Cluster.id)
+            return FanControlServer.with(FanControl.Feature.MultiSpeed, FanControl.Feature.Auto, FanControl.Feature.Step);
+        if (clusterId === TemperatureMeasurement.Cluster.id)
+            return TemperatureMeasurementServer;
+        if (clusterId === RelativeHumidityMeasurement.Cluster.id)
+            return RelativeHumidityMeasurementServer;
+        if (clusterId === PressureMeasurement.Cluster.id)
+            return PressureMeasurementServer.with(PressureMeasurement.Feature.Extended);
+        if (clusterId === FlowMeasurement.Cluster.id)
+            return FlowMeasurementServer;
+        if (clusterId === BooleanState.Cluster.id)
+            return BooleanStateServer;
+        if (clusterId === BooleanStateConfiguration.Cluster.id)
+            return BooleanStateConfigurationServer;
+        if (clusterId === OccupancySensing.Cluster.id)
+            return OccupancySensingServer;
+        if (clusterId === IlluminanceMeasurement.Cluster.id)
+            return IlluminanceMeasurementServer;
+        if (clusterId === BridgedDeviceBasicInformation.Cluster.id)
+            return BridgedDeviceBasicInformationServer;
+        return IdentifyServer;
+    }
+    /**
+     * Loads an instance of the MatterbridgeDevice class.
+     *
+     * @param {DeviceTypeDefinition} definition - The DeviceTypeDefinition of the device.
+     * @returns MatterbridgeDevice instance.
+     */
+    static async loadInstance(definition, options = {}) {
+        return new MatterbridgeEndpoint(definition, options);
+    }
+    /**
+     * Adds a device type to the list of device types.
+     * If the device type is not already present in the list, it will be added.
+     *
+     * @param {DeviceTypeDefinition} deviceType - The device type to add.
+     */
+    addDeviceType(deviceType) {
+        if (!this.deviceTypes.has(deviceType.code)) {
+            // Keep the Matterbridge internal map
+            this.log.debug(`addDeviceType: ${zb}${deviceType.code}${db}-${zb}${deviceType.name}${db}`);
+            this.deviceTypes.set(deviceType.code, deviceType);
+            // Add the device types to the descriptor server
+            const deviceTypeList = Array.from(this.deviceTypes.values()).map((dt) => ({
+                deviceType: dt.code,
+                revision: dt.revision,
+            }));
+            this.behaviors.require(DescriptorServer, {
+                deviceTypeList,
+            });
+        }
+    }
+    /**
+     * Adds one or more device types with the required cluster servers and the specified cluster servers.
+     *
+     * @param {AtLeastOne<DeviceTypeDefinition>} deviceTypes - The device types to add.
+     * @param {ClusterId[]} includeServerList - The list of cluster IDs to include.
+     */
+    addDeviceTypeWithClusterServer(deviceTypes, includeServerList) {
+        this.log.debug('addDeviceTypeWithClusterServer:');
+        deviceTypes.forEach((deviceType) => {
+            this.log.debug(`- with deviceType: ${zb}${deviceType.code}${db}-${zb}${deviceType.name}${db}`);
+            deviceType.requiredServerClusters.forEach((clusterId) => {
+                if (!includeServerList.includes(clusterId))
+                    includeServerList.push(clusterId);
+            });
+        });
+        includeServerList.forEach((clusterId) => {
+            this.log.debug(`- with cluster: ${hk}${clusterId}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
+        });
+        deviceTypes.forEach((deviceType) => {
+            this.addDeviceType(deviceType);
+        });
+        this.addClusterServerFromList(this, includeServerList);
+    }
+    /**
+     * Adds a child endpoint with one or more device types with the required cluster servers and the specified cluster servers.
+     * If the child endpoint is not already present in the childEndpoints, it will be added.
+     * If the child endpoint is already present in the childEndpoints, the device types and cluster servers will be added to the existing child endpoint.
+     *
+     * @param {string} endpointName - The name of the new enpoint to add.
+     * @param {AtLeastOne<DeviceTypeDefinition>} deviceTypes - The device types to add.
+     * @param {ClusterId[]} includeServerList - The list of cluster IDs to include.
+     * @returns {Endpoint} - The child endpoint that was found or added.
+     */
+    addChildDeviceTypeWithClusterServer(endpointName, deviceTypes, includeServerList) {
+        /*
+        this.log.debug(`addChildDeviceTypeWithClusterServer: ${CYAN}${endpointName}${db}`);
+        let child = this.getChildEndpoints().find((endpoint) => endpoint.uniqueStorageKey === endpointName);
+        if (!child) {
+          child = new Endpoint(deviceTypes, { uniqueStorageKey: endpointName });
+          child.addFixedLabel('endpointName', endpointName);
+        }
+        deviceTypes.forEach((deviceType) => {
+          this.log.debug(`- with deviceType: ${zb}${deviceType.code}${db}-${zb}${deviceType.name}${db}`);
+          deviceType.requiredServerClusters.forEach((clusterId) => {
+            if (!includeServerList.includes(clusterId)) includeServerList.push(clusterId);
+          });
+        });
+        includeServerList.forEach((clusterId) => {
+          this.log.debug(`- with cluster: ${hk}${clusterId}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
+        });
+        this.addClusterServerFromList(child, includeServerList);
+        this.addChildEndpoint(child);
+        return child;
+        */
+    }
+    getClusterServer(cluster) {
+        const clusterServer = this.clusterServers.get(cluster.id);
+        if (clusterServer !== undefined) {
+            return clusterServer;
+        }
+    }
+    getClusterServerById(clusterId) {
+        return this.clusterServers.get(clusterId);
+    }
+    addClusterServer(cluster) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const options = {};
+        for (const attribute of Object.values(cluster.attributes)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (attribute.id < 0xfff0) {
+                // No issue here for value, as cluster here is just a definition without getter setter
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                options[attribute.name] = attribute.value;
+            }
+        }
+        this.log.debug(`addClusterServer: ${hk}${cluster.id}${db}-${hk}${getClusterNameById(cluster.id)}${db} with options: ${debugStringify(options)}${rs}`);
+        const behavior = MatterbridgeEndpoint.getBehaviourTypeFromClusterServerId(cluster.id);
+        this.behaviors.require(behavior, options);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.clusterServers.set(cluster.id, cluster);
+    }
+    /**
+     * Adds cluster servers to the specified endpoint based on the provided server list.
+     *
+     * @param {Endpoint} endpoint - The endpoint to add cluster servers to.
+     * @param {ClusterId[]} includeServerList - The list of cluster IDs to include.
+     * @returns void
+     */
+    addClusterServerFromList(endpoint, includeServerList) {
+        if (includeServerList.includes(Identify.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultIdentifyClusterServer());
+        if (includeServerList.includes(Groups.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultGroupsClusterServer());
+        // if (includeServerList.includes(Scenes.Cluster.id)) endpoint.addClusterServer(this.getDefaultScenesClusterServer());
+        if (includeServerList.includes(OnOff.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultOnOffClusterServer());
+        if (includeServerList.includes(LevelControl.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultLevelControlClusterServer());
+        if (includeServerList.includes(ColorControl.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultCompleteColorControlClusterServer());
+        if (includeServerList.includes(Switch.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultSwitchClusterServer());
+        if (includeServerList.includes(DoorLock.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultDoorLockClusterServer());
+        if (includeServerList.includes(Thermostat.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultThermostatClusterServer());
+        if (includeServerList.includes(TimeSynchronization.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultTimeSyncClusterServer());
+        if (includeServerList.includes(WindowCovering.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultWindowCoveringClusterServer());
+        if (includeServerList.includes(FanControl.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultFanControlClusterServer());
+        if (includeServerList.includes(TemperatureMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultTemperatureMeasurementClusterServer());
+        if (includeServerList.includes(RelativeHumidityMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultRelativeHumidityMeasurementClusterServer());
+        if (includeServerList.includes(PressureMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultPressureMeasurementClusterServer());
+        if (includeServerList.includes(FlowMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultFlowMeasurementClusterServer());
+        if (includeServerList.includes(BooleanState.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultBooleanStateClusterServer());
+        if (includeServerList.includes(BooleanStateConfiguration.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultBooleanStateConfigurationClusterServer());
+        if (includeServerList.includes(OccupancySensing.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultOccupancySensingClusterServer());
+        if (includeServerList.includes(IlluminanceMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultIlluminanceMeasurementClusterServer());
+        if (includeServerList.includes(PowerSource.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultPowerSourceWiredClusterServer());
+        if (includeServerList.includes(PowerTopology.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultPowerTopologyClusterServer());
+        if (includeServerList.includes(ElectricalPowerMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultElectricalPowerMeasurementClusterServer());
+        if (includeServerList.includes(ElectricalEnergyMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultElectricalEnergyMeasurementClusterServer());
+        if (includeServerList.includes(SmokeCoAlarm.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultSmokeCOAlarmClusterServer());
+        if (includeServerList.includes(AirQuality.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultAirQualityClusterServer());
+        if (includeServerList.includes(CarbonMonoxideConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultCarbonMonoxideConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(CarbonDioxideConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultCarbonDioxideConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(NitrogenDioxideConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultNitrogenDioxideConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(OzoneConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultOzoneConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(FormaldehydeConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultFormaldehydeConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(Pm1ConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultPm1ConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(Pm25ConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultPm25ConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(Pm10ConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultPm10ConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(RadonConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultRadonConcentrationMeasurementClusterServer());
+        if (includeServerList.includes(TotalVolatileOrganicCompoundsConcentrationMeasurement.Cluster.id))
+            endpoint.addClusterServer(this.getDefaultTvocMeasurementClusterServer());
+        // if (includeServerList.includes(DeviceEnergyManagement.Cluster.id)) endpoint.addClusterServer(this.getDefaultDeviceEnergyManagementClusterServer());
+        // if (includeServerList.includes(DeviceEnergyManagementMode.Cluster.id)) endpoint.addClusterServer(this.getDefaultDeviceEnergyManagementModeClusterServer());
+    }
+    /**
+     * From here copy paste from MatterbridgeDevice
+     */
+    /**
+     * Retrieves a child endpoint by its name.
+     *
+     * @param {string} endpointName - The name of the endpoint to retrieve.
+     * @returns {Endpoint | undefined} The child endpoint with the specified name, or undefined if not found.
+     */
+    /*
+    getChildEndpointByName(endpointName: string): Endpoint | undefined {
+      return this.getChildEndpoints().find((endpoint) => endpoint.uniqueStorageKey === endpointName);
+    }
+    */
+    /**
+     * Retrieves the value of the specified attribute from the given endpoint and cluster.
+     *
+     * @param {ClusterId} clusterId - The ID of the cluster to retrieve the attribute from.
+     * @param {string} attribute - The name of the attribute to retrieve.
+     * @param {AnsiLogger} [log] - Optional logger for error and info messages.
+     * @param {Endpoint} [endpoint] - Optional the child endpoint to retrieve the attribute from.
+     * @returns {any} The value of the attribute, or undefined if the attribute is not found.
+     */
+    /*
+    getAttribute(clusterId: ClusterId, attribute: string, log?: AnsiLogger, endpoint?: Endpoint): any {
+      if (!endpoint) endpoint = this as Endpoint;
+  
+      const clusterServer = endpoint.getClusterServerById(clusterId);
+      if (!clusterServer) {
+        log?.error(`getAttribute error: Cluster ${clusterId} not found on endpoint ${endpoint.name}:${endpoint.number}`);
+        return undefined;
+      }
+      const capitalizedAttributeName = attribute.charAt(0).toUpperCase() + attribute.slice(1);
+      if (!clusterServer.isAttributeSupportedByName(attribute) && !clusterServer.isAttributeSupportedByName(capitalizedAttributeName)) {
+        if (log) log.error(`getAttribute error: Attribute ${attribute} not found on Cluster ${clusterServer.name} on endpoint ${endpoint.name}:${endpoint.number}`);
+        return undefined;
+      }
+      // Find the getter method
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (!(clusterServer as any)[`get${capitalizedAttributeName}Attribute`]) {
+        log?.error(`getAttribute error: Getter get${capitalizedAttributeName}Attribute not found on Cluster ${clusterServer.name} on endpoint ${endpoint.name}:${endpoint.number}`);
+        return undefined;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
+      const getter = (clusterServer as any)[`get${capitalizedAttributeName}Attribute`] as () => {};
+      const value = getter();
+      log?.info(`${db}Get endpoint ${or}${endpoint.name}:${endpoint.number}${db} attribute ${hk}${clusterServer.name}.${capitalizedAttributeName}${db} value ${YELLOW}${typeof value === 'object' ? debugStringify(value) : value}${db}`);
+      return value;
+    }
+    */
+    /**
+     * Sets the value of an attribute on a cluster server endpoint.
+     *
+     * @param {ClusterId} clusterId - The ID of the cluster.
+     * @param {string} attribute - The name of the attribute.
+     * @param {any} value - The value to set for the attribute.
+     * @param {AnsiLogger} [log] - (Optional) The logger to use for logging errors and information.
+     * @param {Endpoint} [endpoint] - (Optional) The endpoint to set the attribute on. If not provided, the attribute will be set on the current endpoint.
+     */
+    /*
+    setAttribute(clusterId: ClusterId, attribute: string, value: any, log?: AnsiLogger, endpoint?: Endpoint): boolean {
+      if (!endpoint) endpoint = this as Endpoint;
+  
+      const clusterServer = endpoint.getClusterServerById(clusterId);
+      if (!clusterServer) {
+        log?.error(`setAttribute error: Cluster ${clusterId} not found on endpoint ${endpoint.name}:${endpoint.number}`);
+        return false;
+      }
+      const capitalizedAttributeName = attribute.charAt(0).toUpperCase() + attribute.slice(1);
+      if (!clusterServer.isAttributeSupportedByName(attribute) && !clusterServer.isAttributeSupportedByName(capitalizedAttributeName)) {
+        if (log) log.error(`setAttribute error: Attribute ${attribute} not found on Cluster ${clusterId} on endpoint ${endpoint.name}:${endpoint.number}`);
+        return false;
+      }
+      // Find the getter method
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (!(clusterServer as any)[`get${capitalizedAttributeName}Attribute`]) {
+        log?.error(`setAttribute error: Getter get${capitalizedAttributeName}Attribute not found on Cluster ${clusterServer.name} on endpoint ${endpoint.name}:${endpoint.number}`);
+        return false;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
+      const getter = (clusterServer as any)[`get${capitalizedAttributeName}Attribute`] as () => {};
+      // Find the setter method
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (!(clusterServer as any)[`set${capitalizedAttributeName}Attribute`]) {
+        log?.error(`setAttribute error: Setter set${capitalizedAttributeName}Attribute not found on Cluster ${clusterServer.name} on endpoint ${endpoint.name}:${endpoint.number}`);
+        return false;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
+      const setter = (clusterServer as any)[`set${capitalizedAttributeName}Attribute`] as (value: any) => {};
+      const oldValue = getter();
+      setter(value);
+      log?.info(
+        `${db}Set endpoint ${or}${endpoint.name}:${endpoint.number}${db} attribute ${hk}${clusterServer.name}.${capitalizedAttributeName}${db} ` +
+          `from ${YELLOW}${typeof oldValue === 'object' ? debugStringify(oldValue) : oldValue}${db} ` +
+          `to ${YELLOW}${typeof value === 'object' ? debugStringify(value) : value}${db}`,
+      );
+      return true;
+    }
+    */
+    /**
+     * Subscribes to an attribute on a cluster.
+     *
+     * @param {ClusterId} clusterId - The ID of the cluster.
+     * @param {string} attribute - The name of the attribute to subscribe to.
+     * @param {(newValue: any, oldValue: any) => void} listener - A callback function that will be called when the attribute value changes.
+     * @param {AnsiLogger} log - (Optional) An AnsiLogger instance for logging errors and information.
+     * @param {Endpoint} endpoint - (Optional) The endpoint to subscribe the attribute on. If not provided, the current endpoint will be used.
+     * @returns A boolean indicating whether the subscription was successful.
+     */
+    /*
+    subscribeAttribute(clusterId: ClusterId, attribute: string, listener: (newValue: any, oldValue: any) => void, log?: AnsiLogger, endpoint?: Endpoint): boolean {
+      if (!endpoint) endpoint = this as Endpoint;
+  
+      const clusterServer = endpoint.getClusterServerById(clusterId);
+      if (!clusterServer) {
+        log?.error(`subscribeAttribute error: Cluster ${clusterId} not found on endpoint ${endpoint.name}:${endpoint.number}`);
+        return false;
+      }
+      const capitalizedAttributeName = attribute.charAt(0).toUpperCase() + attribute.slice(1);
+      if (!clusterServer.isAttributeSupportedByName(attribute) && !clusterServer.isAttributeSupportedByName(capitalizedAttributeName)) {
+        if (log) log.error(`subscribeAttribute error: Attribute ${attribute} not found on Cluster ${clusterServer.name} on endpoint ${endpoint.name}:${endpoint.number}`);
+        return false;
+      }
+      // Find the subscribe method
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (!(clusterServer as any)[`subscribe${capitalizedAttributeName}Attribute`]) {
+        log?.error(`subscribeAttribute error: subscribe${capitalizedAttributeName}Attribute not found on Cluster ${clusterServer.name} on endpoint ${endpoint.name}:${endpoint.number}`);
+        return false;
+      }
+      // Subscribe to the attribute
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
+      const subscribe = (clusterServer as any)[`subscribe${capitalizedAttributeName}Attribute`] as (listener: (newValue: any, oldValue: any) => void) => {};
+      subscribe(listener);
+      log?.info(`${db}Subscribe endpoint ${or}${endpoint.name}:${endpoint.number}${db} attribute ${hk}${clusterServer.name}.${capitalizedAttributeName}${db}`);
+      return true;
+    }
+    */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    addCommandHandler(clusterId, command, handler) {
+        const clusterServer = this.getClusterServerById(clusterId);
+        if (!clusterServer) {
+            this.log.error(`addCommandHandler error: Cluster ${clusterId} not found on endpoint ${this.id}:${this.number}`);
+            return false;
+        }
+        if (!clusterServer.isCommandSupportedByName(command)) {
+            this.log.error(`addCommandHandler error: Command ${command} not found on Cluster ${clusterServer.name} on endpoint ${this.id}:${this.number}`);
+            return false;
+        }
+        // Find the command
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const commands = clusterServer.commands;
+        for (const [key, value] of Object.entries(commands)) {
+            // console.log(`Key "${key}": ${debugStringify(value)}`);
+            if (key === command) {
+                value.handler = handler;
+                this.log.info(`${db}Command handler added for endpoint ${or}${this.id}:${this.number}${db} ${hk}${clusterServer.name}.${command}${db}`);
+                return true;
+            }
+        }
+        this.log.error(`Command handler not found for endpoint ${or}${this.id}:${this.number}${er} ${hk}${clusterServer.name}.${command}${er}`);
+        return false;
+    }
+    /**
+     * Serializes the Matterbridge device into a serialized object.
+     *
+     * @param pluginName - The name of the plugin.
+     * @returns The serialized Matterbridge device object.
+     */
+    /*
+    serialize(): SerializedMatterbridgeDevice | undefined {
+      if (!this.serialNumber || !this.deviceName || !this.uniqueId) return;
+      const cluster = this.getClusterServer(BasicInformationCluster) ?? this.getClusterServer(BridgedDeviceBasicInformationCluster);
+      if (!cluster) return;
+      const serialized: SerializedMatterbridgeDevice = {
+        pluginName: this.plugin ?? 'Unknown',
+        serialNumber: this.serialNumber,
+        deviceName: this.deviceName,
+        uniqueId: this.uniqueId,
+        productName: cluster.attributes.productName?.getLocal(),
+        vendorId: cluster.attributes.vendorId?.getLocal(),
+        vendorName: cluster.attributes.vendorName?.getLocal(),
+        deviceTypes: this.getDeviceTypes(),
+        endpoint: this.number,
+        endpointName: this.name,
+        clusterServersId: [],
+      };
+      this.getAllClusterServers().forEach((clusterServer) => {
+        serialized.clusterServersId.push(clusterServer.id);
+      });
+      return serialized;
+    }
+    */
+    /**
+     * Deserializes the device into a serialized object.
+     *
+     * @returns The deserialized MatterbridgeDevice.
+     */
+    /*
+    static deserialize(serializedDevice: SerializedMatterbridgeDevice): MatterbridgeDevice {
+      const device = new MatterbridgeDevice(serializedDevice.deviceTypes);
+      device.serialNumber = serializedDevice.serialNumber;
+      device.deviceName = serializedDevice.deviceName;
+      device.uniqueId = serializedDevice.uniqueId;
+      for (const clusterId of serializedDevice.clusterServersId) {
+        if (clusterId === BasicInformationCluster.id)
+          device.createDefaultBasicInformationClusterServer(
+            serializedDevice.deviceName,
+            serializedDevice.serialNumber,
+            serializedDevice.vendorId ?? 0xfff1,
+            serializedDevice.vendorName ?? 'Matterbridge',
+            serializedDevice.productId ?? 0x8000,
+            serializedDevice.productName ?? 'Matterbridge device',
+          );
+        else if (clusterId === BridgedDeviceBasicInformationCluster.id)
+          device.createDefaultBridgedDeviceBasicInformationClusterServer(
+            serializedDevice.deviceName,
+            serializedDevice.serialNumber,
+            serializedDevice.vendorId ?? 0xfff1,
+            serializedDevice.vendorName ?? 'Matterbridge',
+            serializedDevice.productName ?? 'Matterbridge device',
+          );
+        else device.addClusterServerFromList(device, [clusterId]);
+      }
+      return device;
+    }
+    */
+    /**
+     * Get a default IdentifyCluster server.
+     */
+    getDefaultIdentifyClusterServer(identifyTime = 0, identifyType = Identify.IdentifyType.None) {
+        return ClusterServer(IdentifyCluster, {
+            identifyTime,
+            identifyType,
+        }, {
+            identify: async (data) => {
+                this.log.debug('Matter command: Identify');
+                await this.commandHandler.executeHandler('identify', data);
+            },
+            triggerEffect: async (data) => {
+                this.log.debug('Matter command: TriggerEffect');
+                await this.commandHandler.executeHandler('triggerEffect', data);
+            },
+        });
+    }
+    /**
+     * Creates a default IdentifyCluster server.
+     */
+    createDefaultIdentifyClusterServer(identifyTime = 0, identifyType = Identify.IdentifyType.None) {
+        this.addClusterServer(this.getDefaultIdentifyClusterServer(identifyTime, identifyType));
+    }
+    /**
+     * Get a default IdentifyCluster server.
+     */
+    getDefaultGroupsClusterServer() {
+        return ClusterServer(GroupsCluster, {
+            nameSupport: {
+                nameSupport: true,
+            },
+        }, GroupsClusterHandler());
+        // return createDefaultGroupsClusterServer();
+    }
+    /**
+     * Creates a default groups cluster server and adds it to the device.
+     */
+    createDefaultGroupsClusterServer() {
+        this.addClusterServer(this.getDefaultGroupsClusterServer());
+    }
+    /**
+     * Get a default scenes cluster server and adds it to the current instance.
+     * @deprecated This method is deprecated.
+     *
+     */
+    getDefaultScenesClusterServer() {
+        /*
+        return ClusterServer(
+          ScenesCluster,
+          {
+            sceneCount: 0,
+            currentScene: 0,
+            currentGroup: GroupId(0),
+            sceneValid: false,
+            nameSupport: {
+              nameSupport: true,
+            },
+            lastConfiguredBy: null,
+          },
+          {},
+        );
+        */
+    }
+    /**
+     * Creates a default scenes cluster server and adds it to the current instance.
+     * @deprecated This method is deprecated.
+     */
+    createDefaultScenesClusterServer() {
+        /*
+        this.addClusterServer(this.getDefaultScenesClusterServer());
+        */
+    }
+    /**
+     * Creates a unique identifier based on the provided parameters.
+     * @param param1 - The first parameter.
+     * @param param2 - The second parameter.
+     * @param param3 - The third parameter.
+     * @param param4 - The fourth parameter.
+     * @returns A unique identifier generated using the MD5 hash algorithm.
+     */
+    createUniqueId(param1, param2, param3, param4) {
+        const hash = createHash('md5');
+        hash.update(param1 + param2 + param3 + param4);
+        return hash.digest('hex');
+    }
+    /**
+     * Get a default Basic Information Cluster Server.
+     *
+     * @param deviceName - The name of the device.
+     * @param serialNumber - The serial number of the device.
+     * @param vendorId - The vendor ID of the device.
+     * @param vendorName - The vendor name of the device.
+     * @param productId - The product ID of the device.
+     * @param productName - The product name of the device.
+     * @param softwareVersion - The software version of the device. Default is 1.
+     * @param softwareVersionString - The software version string of the device. Default is 'v.1.0.0'.
+     * @param hardwareVersion - The hardware version of the device. Default is 1.
+     * @param hardwareVersionString - The hardware version string of the device. Default is 'v.1.0.0'.
+     */
+    getDefaultBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productId, productName, softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
+        return ClusterServer(BasicInformationCluster, {
+            dataModelRevision: 1,
+            location: 'XX',
+            vendorId: VendorId(vendorId),
+            vendorName: vendorName.slice(0, 32),
+            productId: productId,
+            productName: productName.slice(0, 32),
+            productLabel: deviceName.slice(0, 64),
+            nodeLabel: deviceName.slice(0, 32),
+            serialNumber: serialNumber.slice(0, 32),
+            uniqueId: this.createUniqueId(deviceName, serialNumber, vendorName, productName),
+            softwareVersion,
+            softwareVersionString: softwareVersionString.slice(0, 64),
+            hardwareVersion,
+            hardwareVersionString: hardwareVersionString.slice(0, 64),
+            reachable: true,
+            capabilityMinima: { caseSessionsPerFabric: 3, subscriptionsPerFabric: 3 },
+            specificationVersion: Specification.SPECIFICATION_VERSION,
+            maxPathsPerInvoke: 1,
+        }, {}, {
+            startUp: true,
+            shutDown: true,
+            leave: true,
+            reachableChanged: true,
+        });
+    }
+    /**
+     * Creates a default Basic Information Cluster Server.
+     *
+     * @param deviceName - The name of the device.
+     * @param serialNumber - The serial number of the device.
+     * @param vendorId - The vendor ID of the device.
+     * @param vendorName - The vendor name of the device.
+     * @param productId - The product ID of the device.
+     * @param productName - The product name of the device.
+     * @param softwareVersion - The software version of the device. Default is 1.
+     * @param softwareVersionString - The software version string of the device. Default is 'v.1.0.0'.
+     * @param hardwareVersion - The hardware version of the device. Default is 1.
+     * @param hardwareVersionString - The hardware version string of the device. Default is 'v.1.0.0'.
+     */
+    createDefaultBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productId, productName, softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
+        this.deviceName = deviceName;
+        this.serialNumber = serialNumber;
+        this.uniqueId = this.createUniqueId(deviceName, serialNumber, vendorName, productName);
+        if (MatterbridgeEndpoint.bridgeMode === 'bridge') {
+            this.createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productName, softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString);
+            return;
+        }
+        this.addClusterServer(this.getDefaultBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productId, productName, softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString));
+    }
+    /**
+     * Get a default BridgedDeviceBasicInformationClusterServer.
+     *
+     * @param deviceName - The name of the device.
+     * @param serialNumber - The serial number of the device.
+     * @param vendorId - The vendor ID of the device.
+     * @param vendorName - The name of the vendor.
+     * @param productName - The name of the product.
+     * @param softwareVersion - The software version of the device. Default is 1.
+     * @param softwareVersionString - The software version string of the device. Default is 'v.1.0.0'.
+     * @param hardwareVersion - The hardware version of the device. Default is 1.
+     * @param hardwareVersionString - The hardware version string of the device. Default is 'v.1.0.0'.
+     */
+    getDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productName, softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
+        return ClusterServer(BridgedDeviceBasicInformationCluster, {
+            vendorId: vendorId !== undefined ? VendorId(vendorId) : undefined, // 4874
+            vendorName: vendorName.slice(0, 32),
+            productName: productName.slice(0, 32),
+            productLabel: deviceName.slice(0, 64),
+            nodeLabel: deviceName.slice(0, 32),
+            serialNumber: serialNumber.slice(0, 32),
+            uniqueId: this.createUniqueId(deviceName, serialNumber, vendorName, productName),
+            softwareVersion,
+            softwareVersionString: softwareVersionString.slice(0, 64),
+            hardwareVersion,
+            hardwareVersionString: hardwareVersionString.slice(0, 64),
+            reachable: true,
+        }, {}, {
+            startUp: true,
+            shutDown: true,
+            leave: true,
+            reachableChanged: true,
+        });
+    }
+    /**
+     * Creates a default BridgedDeviceBasicInformationClusterServer.
+     *
+     * @param deviceName - The name of the device.
+     * @param serialNumber - The serial number of the device.
+     * @param vendorId - The vendor ID of the device.
+     * @param vendorName - The name of the vendor.
+     * @param productName - The name of the product.
+     * @param softwareVersion - The software version of the device. Default is 1.
+     * @param softwareVersionString - The software version string of the device. Default is 'v.1.0.0'.
+     * @param hardwareVersion - The hardware version of the device. Default is 1.
+     * @param hardwareVersionString - The hardware version string of the device. Default is 'v.1.0.0'.
+     */
+    createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productName, softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
+        this.deviceName = deviceName;
+        this.serialNumber = serialNumber;
+        this.uniqueId = this.createUniqueId(deviceName, serialNumber, vendorName, productName);
+        this.addClusterServer(this.getDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productName, softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString));
+    }
+    /**
+     * Get a default Power Topology Cluster Server. Only needed for an electricalSensor device type.
+     *
+     * @returns {ClusterServer} - The configured Power Topology Cluster Server.
+     */
+    getDefaultPowerTopologyClusterServer() {
+        return ClusterServer(PowerTopologyCluster.with(PowerTopology.Feature.TreeTopology), {}, {}, {});
+    }
+    /**
+     * Get a default Electrical Energy Measurement Cluster Server.
+     *
+     * @param {number} energy - The total consumption value in mW/h.
+     * @returns {ClusterServer} - The configured Electrical Energy Measurement Cluster Server.
+     */
+    getDefaultElectricalEnergyMeasurementClusterServer(energy = null) {
+        return ClusterServer(ElectricalEnergyMeasurementCluster.with(ElectricalEnergyMeasurement.Feature.ImportedEnergy, ElectricalEnergyMeasurement.Feature.ExportedEnergy, ElectricalEnergyMeasurement.Feature.CumulativeEnergy), {
+            accuracy: {
+                measurementType: MeasurementType.ElectricalEnergy,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+            cumulativeEnergyReset: null,
+            cumulativeEnergyImported: energy ? { energy } : null,
+            cumulativeEnergyExported: null,
+        }, {}, {
+            cumulativeEnergyMeasured: true,
+        });
+    }
+    /**
+     * Get a default Electrical Power Measurement Cluster Server.
+     *
+     * @param {number} voltage - The voltage value in millivolts.
+     * @param {number} current - The current value in milliamperes.
+     * @param {number} power - The power value in milliwatts.
+     * @param {number} frequency - The frequency value in millihertz.
+     * @returns {ClusterServer} - The configured Electrical Power Measurement Cluster Server.
+     */
+    getDefaultElectricalPowerMeasurementClusterServer(voltage = null, current = null, power = null, frequency = null) {
+        return ClusterServer(ElectricalPowerMeasurementCluster.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), {
+            powerMode: ElectricalPowerMeasurement.PowerMode.Ac,
+            numberOfMeasurementTypes: 3,
+            accuracy: [
+                {
+                    measurementType: MeasurementType.Voltage,
+                    measured: true,
+                    minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                    maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                    accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+                },
+                {
+                    measurementType: MeasurementType.ActiveCurrent,
+                    measured: true,
+                    minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                    maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                    accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+                },
+                {
+                    measurementType: MeasurementType.ActivePower,
+                    measured: true,
+                    minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                    maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                    accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+                },
+                {
+                    measurementType: MeasurementType.Frequency,
+                    measured: true,
+                    minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                    maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                    accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+                },
+            ],
+            voltage: voltage,
+            activeCurrent: current,
+            activePower: power,
+            frequency: frequency,
+        }, {}, {});
+    }
+    /**
+     * Creates a default Dummy Thread Network Diagnostics Cluster server.
+     * @deprecated This method is deprecated and is only used for testing.
+     *
+     * @remarks
+     * This method adds a cluster server used only to give the networkName to Eve app.
+     *
+     * @returns void
+     */
+    createDefaultDummyThreadNetworkDiagnosticsClusterServer() {
+        this.addClusterServer(ClusterServer(ThreadNetworkDiagnosticsCluster.with(ThreadNetworkDiagnostics.Feature.PacketCounts, ThreadNetworkDiagnostics.Feature.ErrorCounts), {
+            channel: 1,
+            routingRole: ThreadNetworkDiagnostics.RoutingRole.Router,
+            networkName: 'MyMatterThread',
+            panId: 0,
+            extendedPanId: 0,
+            meshLocalPrefix: null,
+            neighborTable: [],
+            routeTable: [],
+            partitionId: null,
+            weighting: null,
+            dataVersion: null,
+            stableDataVersion: null,
+            leaderRouterId: null,
+            securityPolicy: null,
+            channelPage0Mask: null,
+            operationalDatasetComponents: null,
+            overrunCount: 0,
+            activeNetworkFaultsList: [],
+        }, {
+            resetCounts: async (data) => {
+                this.log.debug('Matter command: resetCounts');
+                await this.commandHandler.executeHandler('resetCounts', data);
+            },
+        }, {}));
+    }
+    /**
+     * Get a default OnOff cluster server.
+     *
+     * @param onOff - The initial state of the OnOff cluster (default: false).
+     */
+    getDefaultOnOffClusterServer(onOff = false) {
+        return ClusterServer(OnOffCluster, {
+            onOff,
+        }, {
+            on: async (data) => {
+                this.log.debug('Matter command: on onOff:', data.attributes.onOff.getLocal());
+                await this.commandHandler.executeHandler('on', data);
+            },
+            off: async (data) => {
+                this.log.debug('Matter command: off onOff:', data.attributes.onOff.getLocal());
+                await this.commandHandler.executeHandler('off', data);
+            },
+            toggle: async (data) => {
+                this.log.debug('Matter command: toggle onOff:', data.attributes.onOff.getLocal());
+                await this.commandHandler.executeHandler('toggle', data);
+            },
+        }, {});
+    }
+    /**
+     * Creates a default OnOff cluster server.
+     *
+     * @param onOff - The initial state of the OnOff cluster (default: false).
+     */
+    createDefaultOnOffClusterServer(onOff = false) {
+        this.addClusterServer(this.getDefaultOnOffClusterServer(onOff));
+    }
+    /**
+     * Get a default level control cluster server.
+     *
+     * @param currentLevel - The current level (default: 0).
+     */
+    getDefaultLevelControlClusterServer(currentLevel = 0) {
+        return ClusterServer(LevelControlCluster.with(LevelControl.Feature.OnOff), {
+            currentLevel,
+            onLevel: 0,
+            options: {
+                executeIfOff: false,
+                coupleColorTempToLevel: false,
+            },
+        }, {
+            moveToLevel: async (data) => {
+                this.log.debug('Matter command: moveToLevel request:', data.request, 'attributes.currentLevel:', data.attributes.currentLevel.getLocal());
+                await this.commandHandler.executeHandler('moveToLevel', data);
+            },
+            move: async () => {
+                this.log.error('Matter command: move not implemented');
+            },
+            step: async () => {
+                this.log.error('Matter command: step not implemented');
+            },
+            stop: async () => {
+                this.log.error('Matter command: stop not implemented');
+            },
+            moveToLevelWithOnOff: async (data) => {
+                this.log.debug('Matter command: moveToLevelWithOnOff request:', data.request, 'attributes.currentLevel:', data.attributes.currentLevel.getLocal());
+                await this.commandHandler.executeHandler('moveToLevelWithOnOff', data);
+            },
+            moveWithOnOff: async () => {
+                this.log.error('Matter command: moveWithOnOff not implemented');
+            },
+            stepWithOnOff: async () => {
+                this.log.error('Matter command: stepWithOnOff not implemented');
+            },
+            stopWithOnOff: async () => {
+                this.log.error('Matter command: stopWithOnOff not implemented');
+            },
+        });
+    }
+    /**
+     * Creates a default level control cluster server.
+     *
+     * @param currentLevel - The current level (default: 0).
+     */
+    createDefaultLevelControlClusterServer(currentLevel = 0) {
+        this.addClusterServer(this.getDefaultLevelControlClusterServer(currentLevel));
+    }
+    /**
+     * Get a default color control cluster server.
+     *
+     * @param currentX - The current X value.
+     * @param currentY - The current Y value.
+     * @param currentHue - The current hue value.
+     * @param currentSaturation - The current saturation value.
+     * @param colorTemperatureMireds - The color temperature in mireds.
+     * @param colorTempPhysicalMinMireds - The physical minimum color temperature in mireds.
+     * @param colorTempPhysicalMaxMireds - The physical maximum color temperature in mireds.
+     */
+    getDefaultCompleteColorControlClusterServer(currentX = 0, currentY = 0, currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+        return ClusterServer(ColorControlCluster.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.ColorTemperature), {
+            colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
+            enhancedColorMode: ColorControl.EnhancedColorMode.CurrentHueAndCurrentSaturation,
+            colorCapabilities: { xy: true, hueSaturation: true, colorLoop: false, enhancedHue: false, colorTemperature: true },
+            options: {
+                executeIfOff: false,
+            },
+            numberOfPrimaries: null,
+            currentX,
+            currentY,
+            currentHue,
+            currentSaturation,
+            colorTemperatureMireds,
+            colorTempPhysicalMinMireds,
+            colorTempPhysicalMaxMireds,
+        }, {
+            moveToColor: async (data) => {
+                this.log.debug('Matter command: moveToColor request:', data.request, 'attributes.currentX:', data.attributes.currentX.getLocal(), 'attributes.currentY:', data.attributes.currentY.getLocal());
+                this.commandHandler.executeHandler('moveToColor', data);
+            },
+            moveColor: async () => {
+                this.log.error('Matter command: moveColor not implemented');
+            },
+            stepColor: async () => {
+                this.log.error('Matter command: stepColor not implemented');
+            },
+            moveToHue: async (data) => {
+                this.log.debug('Matter command: moveToHue request:', data.request, 'attributes.currentHue:', data.attributes.currentHue.getLocal());
+                this.commandHandler.executeHandler('moveToHue', data);
+            },
+            moveHue: async () => {
+                this.log.error('Matter command: moveHue not implemented');
+            },
+            stepHue: async () => {
+                this.log.error('Matter command: stepHue not implemented');
+            },
+            moveToSaturation: async (data) => {
+                this.log.debug('Matter command: moveToSaturation request:', data.request, 'attributes.currentSaturation:', data.attributes.currentSaturation.getLocal());
+                this.commandHandler.executeHandler('moveToSaturation', data);
+            },
+            moveSaturation: async () => {
+                this.log.error('Matter command: moveSaturation not implemented');
+            },
+            stepSaturation: async () => {
+                this.log.error('Matter command: stepSaturation not implemented');
+            },
+            moveToHueAndSaturation: async (data) => {
+                this.log.debug('Matter command: moveToHueAndSaturation request:', data.request, 'attributes.currentHue:', data.attributes.currentHue.getLocal(), 'attributes.currentSaturation:', data.attributes.currentSaturation.getLocal());
+                this.commandHandler.executeHandler('moveToHueAndSaturation', data);
+            },
+            stopMoveStep: async () => {
+                this.log.error('Matter command: stopMoveStep not implemented');
+            },
+            moveToColorTemperature: async (data) => {
+                this.log.debug('Matter command: moveToColorTemperature request:', data.request, 'attributes.colorTemperatureMireds:', data.attributes.colorTemperatureMireds.getLocal());
+                this.commandHandler.executeHandler('moveToColorTemperature', data);
+            },
+            moveColorTemperature: async () => {
+                this.log.error('Matter command: moveColorTemperature not implemented');
+            },
+            stepColorTemperature: async () => {
+                this.log.error('Matter command: stepColorTemperature not implemented');
+            },
+        }, {});
+    }
+    /**
+     * Creates a default color control cluster server.
+     *
+     * @param currentX - The current X value.
+     * @param currentY - The current Y value.
+     * @param currentHue - The current hue value.
+     * @param currentSaturation - The current saturation value.
+     * @param colorTemperatureMireds - The color temperature in mireds.
+     * @param colorTempPhysicalMinMireds - The physical minimum color temperature in mireds.
+     * @param colorTempPhysicalMaxMireds - The physical maximum color temperature in mireds.
+     */
+    createDefaultCompleteColorControlClusterServer(currentX = 0, currentY = 0, currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+        this.addClusterServer(this.getDefaultCompleteColorControlClusterServer(currentX, currentY, currentHue, currentSaturation, colorTemperatureMireds, colorTempPhysicalMinMireds, colorTempPhysicalMaxMireds));
+    }
+    /**
+     * Configures the color control cluster for a device.
+     *
+     * @remark This method must be called only after creating the cluster with getDefaultCompleteColorControlClusterServer or createDefaultCompleteColorControlClusterServer
+     * and before starting the matter server.
+     *
+     * @param {boolean} hueSaturation - A boolean indicating whether the device supports hue and saturation control.
+     * @param {boolean} xy - A boolean indicating whether the device supports XY control.
+     * @param {boolean} colorTemperature - A boolean indicating whether the device supports color temperature control.
+     * @param {ColorControl.ColorMode} colorMode - An optional parameter specifying the color mode of the device.
+     * @param {Endpoint} endpoint - An optional parameter specifying the endpoint to configure. If not provided, the device endpoint will be used.
+     */
+    configureColorControlCluster(hueSaturation, xy, colorTemperature, colorMode, endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        endpoint.getClusterServer(ColorControlCluster)?.setFeatureMapAttribute({ hueSaturation, enhancedHue: false, colorLoop: false, xy, colorTemperature });
+        endpoint.getClusterServer(ColorControlCluster)?.setColorCapabilitiesAttribute({ hueSaturation, enhancedHue: false, colorLoop: false, xy, colorTemperature });
+        if (colorMode !== undefined && colorMode >= 0 && colorMode <= 2) {
+            endpoint.getClusterServer(ColorControlCluster)?.setColorModeAttribute(colorMode);
+            endpoint.getClusterServer(ColorControlCluster)?.setEnhancedColorModeAttribute(colorMode);
+        }
+    }
+    /**
+     * Configures the color control mode for the device.
+     *
+     * @param {ColorControl.ColorMode} colorMode - The color mode to set.
+     * @param {Endpoint} endpoint - The optional endpoint to configure. If not provided, the method will configure the current endpoint.
+     */
+    configureColorControlMode(colorMode, endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        if (colorMode !== undefined && colorMode >= ColorControl.ColorMode.CurrentHueAndCurrentSaturation && colorMode <= ColorControl.ColorMode.ColorTemperatureMireds) {
+            endpoint.getClusterServer(ColorControlCluster)?.setColorModeAttribute(colorMode);
+            endpoint.getClusterServer(ColorControlCluster)?.setEnhancedColorModeAttribute(colorMode);
+        }
+    }
+    /**
+     * Get a default window covering cluster server.
+     *
+     * @param positionPercent100ths - The position percentage in 100ths (0-10000). Defaults to 0.
+     */
+    getDefaultWindowCoveringClusterServer(positionPercent100ths) {
+        return ClusterServer(WindowCoveringCluster.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift), {
+            type: WindowCovering.WindowCoveringType.Rollershade,
+            configStatus: {
+                operational: true,
+                onlineReserved: true,
+                liftMovementReversed: false,
+                liftPositionAware: true,
+                tiltPositionAware: false,
+                liftEncoderControlled: false,
+                tiltEncoderControlled: false,
+            },
+            operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
+            endProductType: WindowCovering.EndProductType.RollerShade,
+            mode: { motorDirectionReversed: false, calibrationMode: false, maintenanceMode: false, ledFeedback: false },
+            targetPositionLiftPercent100ths: positionPercent100ths ?? 0, // 0 Fully open 10000 fully closed
+            currentPositionLiftPercent100ths: positionPercent100ths ?? 0, // 0 Fully open 10000 fully closed
+            // installedClosedLimitLift: 10000,
+            // installedOpenLimitLift: 0,
+        }, {
+            upOrOpen: async (data) => {
+                this.log.debug('Matter command: upOrOpen');
+                await this.commandHandler.executeHandler('upOrOpen', data);
+            },
+            downOrClose: async (data) => {
+                this.log.debug('Matter command: downOrClose');
+                await this.commandHandler.executeHandler('downOrClose', data);
+            },
+            stopMotion: async (data) => {
+                this.log.debug('Matter command: stopMotion');
+                await this.commandHandler.executeHandler('stopMotion', data);
+            },
+            goToLiftPercentage: async (data) => {
+                this.log.debug(`Matter command: goToLiftPercentage: ${data.request.liftPercent100thsValue} current: ${data.attributes.currentPositionLiftPercent100ths?.getLocal()} ` +
+                    `target: ${data.attributes.targetPositionLiftPercent100ths?.getLocal()} status: ${data.attributes.operationalStatus.getLocal().lift}`);
+                await this.commandHandler.executeHandler('goToLiftPercentage', data);
+            },
+        }, {});
+    }
+    /**
+     * Creates a default window covering cluster server.
+     *
+     * @param positionPercent100ths - The position percentage in 100ths (0-10000). Defaults to 0.
+     */
+    createDefaultWindowCoveringClusterServer(positionPercent100ths) {
+        this.addClusterServer(this.getDefaultWindowCoveringClusterServer(positionPercent100ths));
+    }
+    /**
+     * Sets the window covering target position as the current position and stops the movement.
+     * @param {Endpoint} endpoint - The endpoint on which to set the window covering (default the device endpoint).
+     */
+    setWindowCoveringTargetAsCurrentAndStopped(endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        const windowCoveringCluster = endpoint.getClusterServer(WindowCoveringCluster.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift));
+        if (windowCoveringCluster) {
+            const position = windowCoveringCluster.getCurrentPositionLiftPercent100thsAttribute();
+            if (position !== null) {
+                windowCoveringCluster.setTargetPositionLiftPercent100thsAttribute(position);
+                windowCoveringCluster.setOperationalStatusAttribute({
+                    global: WindowCovering.MovementStatus.Stopped,
+                    lift: WindowCovering.MovementStatus.Stopped,
+                    tilt: WindowCovering.MovementStatus.Stopped,
+                });
+            }
+            this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths and targetPositionLiftPercent100ths to ${position} and operationalStatus to Stopped.`);
+        }
+    }
+    /**
+     * Sets the current and target status of a window covering.
+     * @param {number} current - The current position of the window covering.
+     * @param {number} target - The target position of the window covering.
+     * @param {WindowCovering.MovementStatus} status - The movement status of the window covering.
+     * @param {Endpoint} endpoint - The endpoint on which to set the window covering (default the device endpoint).
+     */
+    setWindowCoveringCurrentTargetStatus(current, target, status, endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        const windowCoveringCluster = endpoint.getClusterServer(WindowCoveringCluster.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift));
+        if (windowCoveringCluster) {
+            windowCoveringCluster.setCurrentPositionLiftPercent100thsAttribute(current);
+            windowCoveringCluster.setTargetPositionLiftPercent100thsAttribute(target);
+            windowCoveringCluster.setOperationalStatusAttribute({
+                global: status,
+                lift: status,
+                tilt: status,
+            });
+        }
+        this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths: ${current}, targetPositionLiftPercent100ths: ${target} and operationalStatus: ${status}.`);
+    }
+    /**
+     * Sets the status of the window covering.
+     * @param {WindowCovering.MovementStatus} status - The movement status to set.
+     * @param {Endpoint} endpoint - The endpoint on which to set the window covering (default the device endpoint).
+     */
+    setWindowCoveringStatus(status, endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        const windowCovering = endpoint.getClusterServer(WindowCoveringCluster.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift));
+        if (!windowCovering)
+            return;
+        windowCovering.setOperationalStatusAttribute({ global: status, lift: status, tilt: status });
+        this.log.debug(`Set WindowCovering operationalStatus: ${status}`);
+    }
+    /**
+     * Retrieves the status of the window covering.
+     * @param {Endpoint} endpoint - The endpoint on which to get the window covering (default the device endpoint).
+     *
+     * @returns The global operational status of the window covering.
+     */
+    getWindowCoveringStatus(endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        const windowCovering = endpoint.getClusterServer(WindowCoveringCluster.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift));
+        if (!windowCovering)
+            return undefined;
+        const status = windowCovering.getOperationalStatusAttribute();
+        this.log.debug(`Get WindowCovering operationalStatus: ${status.global}`);
+        return status.global;
+    }
+    /**
+     * Sets the target and current position of the window covering.
+     *
+     * @param position - The position to set, specified as a number.
+     * @param {Endpoint} endpoint - The endpoint on which to set the window covering (default the device endpoint).
+     */
+    setWindowCoveringTargetAndCurrentPosition(position, endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        const windowCovering = endpoint.getClusterServer(WindowCoveringCluster.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift));
+        if (!windowCovering)
+            return;
+        windowCovering.setCurrentPositionLiftPercent100thsAttribute(position);
+        windowCovering.setTargetPositionLiftPercent100thsAttribute(position);
+        this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths: ${position} and targetPositionLiftPercent100ths: ${position}.`);
+    }
+    /**
+     * Get a default door lock cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server for a door lock cluster with default settings.
+     *
+     */
+    getDefaultDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
+        return ClusterServer(DoorLockCluster, {
+            operatingMode: DoorLock.OperatingMode.Normal,
+            lockState,
+            lockType,
+            actuatorEnabled: false,
+            supportedOperatingModes: { normal: true, vacation: false, privacy: false, noRemoteLockUnlock: false, passage: false },
+        }, {
+            lockDoor: async (data) => {
+                this.log.debug('Matter command: lockDoor', data.request);
+                await this.commandHandler.executeHandler('lockDoor', data);
+            },
+            unlockDoor: async (data) => {
+                this.log.debug('Matter command: unlockDoor', data.request);
+                await this.commandHandler.executeHandler('unlockDoor', data);
+            },
+        }, {
+            doorLockAlarm: true,
+            lockOperation: true,
+            lockOperationError: true,
+        });
+    }
+    /**
+     * Creates a default door lock cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server for a door lock cluster with default settings.
+     *
+     */
+    createDefaultDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
+        this.addClusterServer(this.getDefaultDoorLockClusterServer(lockState, lockType));
+    }
+    /**
+     * Get a default momentary switch cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server with default momentary switch features and configurations suitable for (AppleHome) Single Double Long automations.
+     */
+    getDefaultSwitchClusterServer() {
+        return ClusterServer(SwitchCluster.with(Switch.Feature.MomentarySwitch, Switch.Feature.MomentarySwitchRelease, Switch.Feature.MomentarySwitchLongPress, Switch.Feature.MomentarySwitchMultiPress), {
+            numberOfPositions: 2,
+            currentPosition: 0,
+            multiPressMax: 2,
+        }, {}, {
+            initialPress: true,
+            longPress: true,
+            shortRelease: true,
+            longRelease: true,
+            multiPressOngoing: true,
+            multiPressComplete: true,
+        });
+    }
+    /**
+     * Creates a default momentary switch cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server with default momentary switch features and configurations.
+     */
+    createDefaultSwitchClusterServer() {
+        this.addClusterServer(this.getDefaultSwitchClusterServer());
+    }
+    /**
+     * Get a default latching switch cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server with default latching switch features and configuration.
+     */
+    getDefaultLatchingSwitchClusterServer() {
+        return ClusterServer(SwitchCluster.with(Switch.Feature.LatchingSwitch), {
+            numberOfPositions: 2,
+            currentPosition: 0,
+        }, {}, {
+            switchLatched: true,
+        });
+    }
+    /**
+     * Creates a default latching switch cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server with default latching switch features and configuration.
+     */
+    createDefaultLatchingSwitchClusterServer() {
+        this.addClusterServer(this.getDefaultLatchingSwitchClusterServer());
+    }
+    /**
+     * Triggers a switch event on the specified endpoint.
+     *
+     * @param {string} event - The type of event to trigger. Possible values are 'Single', 'Double', 'Long' for momentarySwitch and 'Press', 'Release' for latchingSwitch.
+     * @param {Endpoint} endpoint - The endpoint on which to trigger the event (default the device endpoint).
+     * @returns {void}
+     */
+    triggerSwitchEvent(event, log, endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        if (['Single', 'Double', 'Long'].includes(event)) {
+            const cluster = endpoint.getClusterServer(SwitchCluster.with(Switch.Feature.MomentarySwitch, Switch.Feature.MomentarySwitchRelease, Switch.Feature.MomentarySwitchLongPress, Switch.Feature.MomentarySwitchMultiPress));
+            if (!cluster || !cluster.getFeatureMapAttribute().momentarySwitch) {
+                log?.error(`triggerSwitchEvent ${event} error: Switch cluster with MomentarySwitch not found on endpoint ${endpoint.id}:${endpoint.number}`);
+                return false;
+            }
+            if (endpoint.number === undefined) {
+                log?.error(`triggerSwitchEvent ${event} error: Endpoint number not assigned on endpoint ${endpoint.id}:${endpoint.number}`);
+                return false;
+            }
+            if (event === 'Single') {
+                cluster.setCurrentPositionAttribute(1);
+                cluster.triggerInitialPressEvent({ newPosition: 1 });
+                cluster.setCurrentPositionAttribute(0);
+                cluster.triggerShortReleaseEvent({ previousPosition: 1 });
+                cluster.setCurrentPositionAttribute(0);
+                cluster.triggerMultiPressCompleteEvent({ previousPosition: 1, totalNumberOfPressesCounted: 1 });
+                log?.info(`${db}Trigger endpoint ${or}${endpoint.id}:${endpoint.number}${db} event ${hk}${cluster.name}.SinglePress${db}`);
+            }
+            if (event === 'Double') {
+                cluster.setCurrentPositionAttribute(1);
+                cluster.triggerInitialPressEvent({ newPosition: 1 });
+                cluster.setCurrentPositionAttribute(0);
+                cluster.triggerShortReleaseEvent({ previousPosition: 1 });
+                cluster.setCurrentPositionAttribute(1);
+                cluster.triggerInitialPressEvent({ newPosition: 1 });
+                cluster.triggerMultiPressOngoingEvent({ newPosition: 1, currentNumberOfPressesCounted: 2 });
+                cluster.setCurrentPositionAttribute(0);
+                cluster.triggerShortReleaseEvent({ previousPosition: 1 });
+                cluster.triggerMultiPressCompleteEvent({ previousPosition: 1, totalNumberOfPressesCounted: 2 });
+                log?.info(`${db}Trigger endpoint ${or}${endpoint.id}:${endpoint.number}${db} event ${hk}${cluster.name}.DoublePress${db}`);
+            }
+            if (event === 'Long') {
+                cluster.setCurrentPositionAttribute(1);
+                cluster.triggerInitialPressEvent({ newPosition: 1 });
+                cluster.triggerLongPressEvent({ newPosition: 1 });
+                cluster.setCurrentPositionAttribute(0);
+                cluster.triggerLongReleaseEvent({ previousPosition: 1 });
+                log?.info(`${db}Trigger endpoint ${or}${endpoint.id}:${endpoint.number}${db} event ${hk}${cluster.name}.LongPress${db}`);
+            }
+        }
+        if (['Press', 'Release'].includes(event)) {
+            const cluster = endpoint.getClusterServer(Switch.Complete);
+            if (!cluster || !cluster.getFeatureMapAttribute().latchingSwitch) {
+                log?.error(`triggerSwitchEvent ${event} error: Switch cluster with LatchingSwitch not found on endpoint ${endpoint.id}:${endpoint.number}`);
+                return false;
+            }
+            if (endpoint.number === undefined) {
+                log?.error(`triggerSwitchEvent ${event} error: Endpoint number not assigned on endpoint ${endpoint.id}:${endpoint.number}`);
+                return false;
+            }
+            if (event === 'Press') {
+                cluster.setCurrentPositionAttribute(1);
+                log?.info(`${db}Update endpoint ${or}${endpoint.id}:${endpoint.number}${db} attribute ${hk}${cluster.name}.CurrentPosition${db} to ${YELLOW}1${db}`);
+                if (cluster.triggerSwitchLatchedEvent)
+                    cluster.triggerSwitchLatchedEvent({ newPosition: 1 });
+                log?.info(`${db}Trigger endpoint ${or}${endpoint.id}:${endpoint.number}${db} event ${hk}${cluster.name}.Press${db}`);
+            }
+            if (event === 'Release') {
+                cluster.setCurrentPositionAttribute(0);
+                log?.info(`${db}Update endpoint ${or}${endpoint.id}:${endpoint.number}${db} attribute ${hk}${cluster.name}.CurrentPosition${db} to ${YELLOW}0${db}`);
+                if (cluster.triggerSwitchLatchedEvent)
+                    cluster.triggerSwitchLatchedEvent({ newPosition: 0 });
+                log?.info(`${db}Trigger endpoint ${or}${endpoint.id}:${endpoint.number}${db} event ${hk}${cluster.name}.Release${db}`);
+            }
+        }
+        return true;
+    }
+    /**
+     * Retrieves the default mode select cluster server.
+     *
+     * @param description - The description of the cluster server.
+     * @param supportedModes - The supported modes for the cluster server.
+     * @param currentMode - The current mode of the cluster server. Defaults to 0.
+     * @param startUpMode - The startup mode of the cluster server. Defaults to 0.
+     * @returns The default mode select cluster server.
+     */
+    getDefaultModeSelectClusterServer(description, supportedModes, currentMode = 0, startUpMode = 0) {
+        return ClusterServer(ModeSelectCluster, {
+            description: description,
+            standardNamespace: null,
+            supportedModes: supportedModes,
+            currentMode: currentMode,
+            startUpMode: startUpMode,
+        }, {
+            changeToMode: async (data) => {
+                this.log.debug('Matter command: ModeSelectCluster.changeToMode', data.request);
+                await this.commandHandler.executeHandler('changeToMode', data);
+            },
+        });
+    }
+    /**
+     * Creates a default mode select cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server for a mode select cluster with default settings.
+     *
+     * @param endpoint - The endpoint to add the cluster server to. Defaults to `this` if not provided.
+     */
+    createDefaultModeSelectClusterServer(description, supportedModes, currentMode = 0, startUpMode = 0, endpoint) {
+        if (!endpoint)
+            endpoint = this;
+        endpoint.addClusterServer(this.getDefaultModeSelectClusterServer(description, supportedModes, currentMode, startUpMode));
+    }
+    /**
+     * Get a default occupancy sensing cluster server.
+     *
+     * @param occupied - A boolean indicating whether the occupancy is occupied or not. Default is false.
+     */
+    getDefaultOccupancySensingClusterServer(occupied = false) {
+        return ClusterServer(OccupancySensingCluster, {
+            occupancy: { occupied },
+            occupancySensorType: OccupancySensing.OccupancySensorType.Pir,
+            occupancySensorTypeBitmap: { pir: true, ultrasonic: false, physicalContact: false },
+            pirOccupiedToUnoccupiedDelay: 30,
+        }, {});
+    }
+    /**
+     * Creates a default occupancy sensing cluster server.
+     *
+     * @param occupied - A boolean indicating whether the occupancy is occupied or not. Default is false.
+     */
+    createDefaultOccupancySensingClusterServer(occupied = false) {
+        this.addClusterServer(this.getDefaultOccupancySensingClusterServer(occupied));
+    }
+    /**
+     * Get a default Illuminance Measurement Cluster Server.
+     *
+     * @param measuredValue - The measured value of illuminance.
+     */
+    getDefaultIlluminanceMeasurementClusterServer(measuredValue = 0) {
+        return ClusterServer(IlluminanceMeasurementCluster, {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            tolerance: 0,
+        }, {}, {});
+    }
+    /**
+     * Creates a default Illuminance Measurement Cluster Server.
+     *
+     * @param measuredValue - The measured value of illuminance.
+     */
+    createDefaultIlluminanceMeasurementClusterServer(measuredValue = 0) {
+        this.addClusterServer(this.getDefaultIlluminanceMeasurementClusterServer(measuredValue));
+    }
+    /**
+     * Get a default flow measurement cluster server.
+     *
+     * @param measuredValue - The measured value of the temperature.
+     */
+    getDefaultFlowMeasurementClusterServer(measuredValue = 0) {
+        return ClusterServer(FlowMeasurementCluster, {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            tolerance: 0,
+        }, {}, {});
+    }
+    /**
+     * Creates a default flow measurement cluster server.
+     *
+     * @param measuredValue - The measured value of the temperature.
+     */
+    createDefaultFlowMeasurementClusterServer(measuredValue = 0) {
+        this.addClusterServer(this.getDefaultFlowMeasurementClusterServer(measuredValue));
+    }
+    /**
+     * Get a default temperature measurement cluster server.
+     *
+     * @param measuredValue - The measured value of the temperature.
+     */
+    getDefaultTemperatureMeasurementClusterServer(measuredValue = 0) {
+        return ClusterServer(TemperatureMeasurementCluster, {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            tolerance: 0,
+        }, {}, {});
+    }
+    /**
+     * Creates a default temperature measurement cluster server.
+     *
+     * @param measuredValue - The measured value of the temperature.
+     */
+    createDefaultTemperatureMeasurementClusterServer(measuredValue = 0) {
+        this.addClusterServer(this.getDefaultTemperatureMeasurementClusterServer(measuredValue));
+    }
+    /**
+     * Get a default RelativeHumidityMeasurementCluster server.
+     *
+     * @param measuredValue - The measured value of the relative humidity.
+     */
+    getDefaultRelativeHumidityMeasurementClusterServer(measuredValue = 0) {
+        return ClusterServer(RelativeHumidityMeasurementCluster, {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            tolerance: 0,
+        }, {}, {});
+    }
+    /**
+     * Creates a default RelativeHumidityMeasurementCluster server.
+     *
+     * @param measuredValue - The measured value of the relative humidity.
+     */
+    createDefaultRelativeHumidityMeasurementClusterServer(measuredValue = 0) {
+        this.addClusterServer(this.getDefaultRelativeHumidityMeasurementClusterServer(measuredValue));
+    }
+    /**
+     * Get a default Pressure Measurement Cluster Server.
+     *
+     * @param measuredValue - The measured value for the pressure.
+     */
+    getDefaultPressureMeasurementClusterServer(measuredValue = 1000) {
+        return ClusterServer(PressureMeasurementCluster, {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            tolerance: 0,
+        }, {}, {});
+    }
+    /**
+     * Creates a default Pressure Measurement Cluster Server.
+     *
+     * @param measuredValue - The measured value for the pressure.
+     */
+    createDefaultPressureMeasurementClusterServer(measuredValue = 1000) {
+        this.addClusterServer(this.getDefaultPressureMeasurementClusterServer(measuredValue));
+    }
+    /**
+     * Get a default boolean state cluster server.
+     *
+     * @param contact - Optional boolean value indicating the contact state. Defaults to `true` if not provided.
+     */
+    getDefaultBooleanStateClusterServer(contact) {
+        return ClusterServer(BooleanStateCluster, {
+            stateValue: contact ?? true, // true=contact false=no_contact
+        }, {}, {
+            stateChange: true,
+        });
+    }
+    /**
+     * Creates a default boolean state configuration cluster server.
+     *
+     * @param contact - Optional boolean value indicating the contact state. Defaults to `true` if not provided.
+     */
+    createDefaultBooleanStateClusterServer(contact) {
+        this.addClusterServer(this.getDefaultBooleanStateClusterServer(contact));
+    }
+    /**
+     * Get a default boolean state configuration cluster server.
+     *
+     * @param contact - Optional boolean value indicating the sensor fault state. Defaults to `false` if not provided.
+     */
+    getDefaultBooleanStateConfigurationClusterServer(sensorFault = false) {
+        return ClusterServer(BooleanStateConfigurationCluster.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel), {
+            currentSensitivityLevel: 0,
+            supportedSensitivityLevels: 2,
+            defaultSensitivityLevel: 0,
+            alarmsActive: { visual: false, audible: false },
+            alarmsEnabled: { visual: false, audible: false },
+            alarmsSupported: { visual: true, audible: true },
+            // alarmsSuppressed: { visual: false, audible: false },
+            sensorFault: { generalFault: sensorFault },
+        }, {
+            enableDisableAlarm: async (data) => {
+                this.log.debug('Matter command: enableDisableAlarm', data.request);
+                await this.commandHandler.executeHandler('enableDisableAlarm', data);
+            },
+        }, {
+            alarmsStateChanged: true,
+            sensorFault: true,
+        });
+    }
+    /**
+     * Creates a default boolean state configuration cluster server.
+     *
+     * @param contact - Optional boolean value indicating the sensor fault state. Defaults to `false` if not provided.
+     */
+    createDefaultBooleanStateConfigurationClusterServer(sensorFault = false) {
+        this.addClusterServer(this.getDefaultBooleanStateConfigurationClusterServer(sensorFault));
+    }
+    /**
+     * Get a default power source replaceable battery cluster server.
+     *
+     * @param batPercentRemaining - The remaining battery percentage (default: 100).
+     * @param batChargeLevel - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+     * @param batVoltage - The battery voltage (default: 1500).
+     * @param batReplacementDescription - The battery replacement description (default: 'Battery type').
+     * @param batQuantity - The battery quantity (default: 1).
+     */
+    getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1) {
+        return ClusterServer(PowerSourceCluster.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), {
+            status: PowerSource.PowerSourceStatus.Active,
+            order: 0,
+            description: 'Primary battery',
+            batVoltage,
+            batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
+            batChargeLevel,
+            batReplacementNeeded: false,
+            batReplaceability: PowerSource.BatReplaceability.UserReplaceable,
+            activeBatFaults: undefined,
+            batReplacementDescription,
+            batQuantity,
+            endpointList: [],
+        }, {}, {});
+    }
+    /**
+     * Creates a default power source replaceable battery cluster server.
+     *
+     * @param batPercentRemaining - The remaining battery percentage (default: 100).
+     * @param batChargeLevel - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+     * @param batVoltage - The battery voltage (default: 1500).
+     * @param batReplacementDescription - The battery replacement description (default: 'Battery type').
+     * @param batQuantity - The battery quantity (default: 1).
+     */
+    createDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1) {
+        this.addClusterServer(this.getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage, batReplacementDescription, batQuantity));
+    }
+    /**
+     * Get a default power source rechargeable battery cluster server.
+     *
+     * @param batPercentRemaining - The remaining battery percentage (default: 100).
+     * @param batChargeLevel - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+     * @param batVoltage - The battery voltage (default: 1500).
+     */
+    getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500) {
+        return ClusterServer(PowerSourceCluster.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), {
+            status: PowerSource.PowerSourceStatus.Active,
+            order: 0,
+            description: 'Primary battery',
+            batVoltage,
+            batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
+            batTimeRemaining: 1,
+            batChargeLevel,
+            batReplacementNeeded: false,
+            batReplaceability: PowerSource.BatReplaceability.Unspecified,
+            activeBatFaults: undefined,
+            batChargeState: PowerSource.BatChargeState.IsNotCharging,
+            batFunctionalWhileCharging: true,
+            endpointList: [],
+        }, {}, {});
+    }
+    /**
+     * Creates a default power source rechargeable battery cluster server.
+     *
+     * @param batPercentRemaining - The remaining battery percentage (default: 100).
+     * @param batChargeLevel - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+     * @param batVoltage - The battery voltage (default: 1500).
+     */
+    createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500) {
+        this.addClusterServer(this.getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage));
+    }
+    /**
+     * Get a default power source wired cluster server.
+     *
+     * @param wiredCurrentType - The type of wired current (default: PowerSource.WiredCurrentType.Ac)
+     */
+    getDefaultPowerSourceWiredClusterServer(wiredCurrentType = PowerSource.WiredCurrentType.Ac) {
+        return ClusterServer(PowerSourceCluster.with(PowerSource.Feature.Wired), {
+            wiredCurrentType,
+            description: wiredCurrentType === PowerSource.WiredCurrentType.Ac ? 'AC Power' : 'DC Power',
+            status: PowerSource.PowerSourceStatus.Active,
+            order: 0,
+            endpointList: [],
+        }, {}, {});
+    }
+    /**
+     * Creates a default power source wired cluster server.
+     *
+     * @param wiredCurrentType - The type of wired current (default: PowerSource.WiredCurrentType.Ac)
+     */
+    createDefaultPowerSourceWiredClusterServer(wiredCurrentType = PowerSource.WiredCurrentType.Ac) {
+        this.addClusterServer(this.getDefaultPowerSourceWiredClusterServer(wiredCurrentType));
+    }
+    /**
+     * @deprecated This function is deprecated by Matter 1.3 spec and will be removed in a future version.
+     */
+    createDefaultPowerSourceConfigurationClusterServer(endpointNumber) {
+        this.addClusterServer(ClusterServer(PowerSourceConfigurationCluster, {
+            sources: endpointNumber ? [EndpointNumber(endpointNumber)] : [],
+        }, {}, {}));
+    }
+    /**
+     * Get a default air quality cluster server.
+     *
+     * @param airQuality The air quality type. Defaults to `AirQuality.AirQualityType.Unknown`.
+     */
+    getDefaultAirQualityClusterServer(airQuality = AirQuality.AirQualityEnum.Unknown) {
+        return ClusterServer(AirQualityCluster.with(AirQuality.Feature.Fair, AirQuality.Feature.Moderate, AirQuality.Feature.VeryPoor, AirQuality.Feature.ExtremelyPoor), {
+            airQuality,
+        }, {}, {});
+    }
+    /**
+     * Creates a default air quality cluster server.
+     *
+     * @param airQuality The air quality type. Defaults to `AirQuality.AirQualityType.Unknown`.
+     */
+    createDefaultAirQualityClusterServer(airQuality = AirQuality.AirQualityEnum.Unknown) {
+        this.addClusterServer(this.getDefaultAirQualityClusterServer(airQuality));
+    }
+    /**
+     * Get a default TVOC measurement cluster server.
+     *
+     * @param measuredValue - The measured value for TVOC.
+     */
+    getDefaultTvocMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Creates a default TVOC measurement cluster server.
+     *
+     * @param measuredValue - The measured value for TVOC.
+     */
+    createDefaultTvocMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultTvocMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Get a default thermostat cluster server with the specified parameters.
+     *
+     * @param {number} [localTemperature=23] - The local temperature value in degrees Celsius. Defaults to 23°.
+     * @param {number} [occupiedHeatingSetpoint=21] - The occupied heating setpoint value in degrees Celsius. Defaults to 21°.
+     * @param {number} [occupiedCoolingSetpoint=25] - The occupied cooling setpoint value in degrees Celsius. Defaults to 25°.
+     * @param {number} [minSetpointDeadBand=1] - The minimum setpoint dead band value. Defaults to 1°.
+     * @param {number} [minHeatSetpointLimit=0] - The minimum heat setpoint limit value. Defaults to 0°.
+     * @param {number} [maxHeatSetpointLimit=50] - The maximum heat setpoint limit value. Defaults to 50°.
+     * @param {number} [minCoolSetpointLimit=0] - The minimum cool setpoint limit value. Defaults to 0°.
+     * @param {number} [maxCoolSetpointLimit=50] - The maximum cool setpoint limit value. Defaults to 50°.
+     * @returns {ThermostatClusterServer} A default thermostat cluster server configured with the specified parameters.
+     */
+    getDefaultThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 1, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50) {
+        return ClusterServer(ThermostatCluster.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode), {
+            localTemperature: localTemperature * 100,
+            occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
+            occupiedCoolingSetpoint: occupiedCoolingSetpoint * 100,
+            minHeatSetpointLimit: minHeatSetpointLimit * 100,
+            maxHeatSetpointLimit: maxHeatSetpointLimit * 100,
+            absMinHeatSetpointLimit: minHeatSetpointLimit * 100,
+            absMaxHeatSetpointLimit: maxHeatSetpointLimit * 100,
+            minCoolSetpointLimit: minCoolSetpointLimit * 100,
+            maxCoolSetpointLimit: maxCoolSetpointLimit * 100,
+            absMinCoolSetpointLimit: minCoolSetpointLimit * 100,
+            absMaxCoolSetpointLimit: maxCoolSetpointLimit * 100,
+            minSetpointDeadBand: minSetpointDeadBand * 100,
+            systemMode: Thermostat.SystemMode.Off,
+            controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingAndHeating,
+            thermostatRunningMode: Thermostat.ThermostatRunningMode.Off,
+        }, {
+            setpointRaiseLower: async (data) => {
+                this.log.debug('Matter command: setpointRaiseLower', data.request);
+                await this.commandHandler.executeHandler('setpointRaiseLower', data);
+            },
+        }, {});
+    }
+    /**
+     * Creates and adds a default thermostat cluster server to the device.
+     *
+     * @param {number} [localTemperature=23] - The local temperature value in degrees Celsius. Defaults to 23°.
+     * @param {number} [occupiedHeatingSetpoint=21] - The occupied heating setpoint value in degrees Celsius. Defaults to 21°.
+     * @param {number} [occupiedCoolingSetpoint=25] - The occupied cooling setpoint value in degrees Celsius. Defaults to 25°.
+     * @param {number} [minSetpointDeadBand=1] - The minimum setpoint dead band value. Defaults to 1°.
+     * @param {number} [minHeatSetpointLimit=0] - The minimum heat setpoint limit value. Defaults to 0°.
+     * @param {number} [maxHeatSetpointLimit=50] - The maximum heat setpoint limit value. Defaults to 50°.
+     * @param {number} [minCoolSetpointLimit=0] - The minimum cool setpoint limit value. Defaults to 0°.
+     * @param {number} [maxCoolSetpointLimit=50] - The maximum cool setpoint limit value. Defaults to 50°.
+     */
+    createDefaultThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 1, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50) {
+        this.addClusterServer(this.getDefaultThermostatClusterServer(localTemperature, occupiedHeatingSetpoint, occupiedCoolingSetpoint, minSetpointDeadBand, minHeatSetpointLimit, maxHeatSetpointLimit, minCoolSetpointLimit, maxCoolSetpointLimit));
+    }
+    /**
+     * Get a default dummy time sync cluster server. Only needed to create a thermostat.
+     */
+    getDefaultTimeSyncClusterServer() {
+        return ClusterServer(TimeSynchronizationCluster.with(TimeSynchronization.Feature.TimeZone), {
+            utcTime: null,
+            granularity: TimeSynchronization.Granularity.NoTimeGranularity,
+            timeZone: [{ offset: 0, validAt: 0 }],
+            dstOffset: [],
+            localTime: null,
+            timeZoneDatabase: TimeSynchronization.TimeZoneDatabase.None,
+            timeZoneListMaxSize: 1,
+            dstOffsetListMaxSize: 1,
+        }, {
+            setTimeZone: async (data) => {
+                this.log.debug('Matter command: setTimeZone', data.request);
+                await this.commandHandler.executeHandler('setTimeZone', data);
+                return { dstOffsetsRequired: false };
+            },
+            setDstOffset: async (data) => {
+                this.log.debug('Matter command: setDstOffset', data.request);
+                await this.commandHandler.executeHandler('setDstOffset', data);
+            },
+            setUtcTime: async (data) => {
+                this.log.debug('Matter command: setUtcTime', data.request);
+                await this.commandHandler.executeHandler('setUtcTime', data);
+            },
+        }, {
+            dstTableEmpty: true,
+            dstStatus: true,
+            timeZoneStatus: true,
+            timeFailure: true,
+        });
+    }
+    /**
+     * Creates a default dummy time sync cluster server. Only needed to create a thermostat.
+     */
+    createDefaultTimeSyncClusterServer() {
+        this.addClusterServer(this.getDefaultTimeSyncClusterServer());
+    }
+    /**
+     * Returns the default SmokeCOAlarm Cluster Server.
+     *
+     * @param smokeState - The state of the smoke alarm. Defaults to SmokeCoAlarm.AlarmState.Normal.
+     * @param coState - The state of the CO alarm. Defaults to SmokeCoAlarm.AlarmState.Normal.
+     * @returns The default SmokeCOAlarmClusterServer.
+     */
+    getDefaultSmokeCOAlarmClusterServer(smokeState = SmokeCoAlarm.AlarmState.Normal, coState = SmokeCoAlarm.AlarmState.Normal) {
+        return ClusterServer(SmokeCoAlarmCluster.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm), {
+            smokeState,
+            coState,
+            expressedState: SmokeCoAlarm.ExpressedState.Normal,
+            batteryAlert: SmokeCoAlarm.AlarmState.Normal,
+            deviceMuted: SmokeCoAlarm.MuteState.NotMuted,
+            testInProgress: false,
+            hardwareFaultAlert: false,
+            endOfServiceAlert: SmokeCoAlarm.EndOfService.Normal,
+            interconnectSmokeAlarm: SmokeCoAlarm.AlarmState.Normal,
+            interconnectCoAlarm: SmokeCoAlarm.AlarmState.Normal,
+        }, {
+            selfTestRequest: async (data) => {
+                this.log.debug('Matter command: selfTestRequest');
+                await this.commandHandler.executeHandler('selfTestRequest', data);
+            },
+        }, {
+            smokeAlarm: true,
+            interconnectSmokeAlarm: true,
+            coAlarm: true,
+            interconnectCoAlarm: true,
+            lowBattery: true,
+            hardwareFault: true,
+            endOfService: true,
+            selfTestComplete: true,
+            alarmMuted: true,
+            muteEnded: true,
+            allClear: true,
+        });
+    }
+    /**
+     * Create the default SmokeCOAlarm Cluster Server.
+     *
+     * @param smokeState - The state of the smoke alarm. Defaults to SmokeCoAlarm.AlarmState.Normal.
+     * @param coState - The state of the CO alarm. Defaults to SmokeCoAlarm.AlarmState.Normal.
+     * @returns The default SmokeCOAlarmClusterServer.
+     */
+    createDefaultSmokeCOAlarmClusterServer(smokeState = SmokeCoAlarm.AlarmState.Normal, coState = SmokeCoAlarm.AlarmState.Normal) {
+        this.addClusterServer(this.getDefaultSmokeCOAlarmClusterServer(smokeState, coState));
+    }
+    /**
+     * Returns the default Carbon Monoxide Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultCarbonMonoxideConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(CarbonMonoxideConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Carbon Monoxide Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaultCarbonMonoxideConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultCarbonMonoxideConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default Carbon Dioxide Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultCarbonDioxideConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(CarbonDioxideConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Carbon Dioxide Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaultCarbonDioxideConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultCarbonDioxideConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default Formaldehyde Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultFormaldehydeConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(FormaldehydeConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Formaldehyde Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaultFormaldehydeConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultFormaldehydeConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default Pm1 Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultPm1ConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(Pm1ConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Pm1 Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaulPm1ConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultPm1ConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default Pm25 Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultPm25ConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(Pm25ConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Pm25 Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaulPm25ConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultPm25ConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default Pm10 Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultPm10ConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(Pm10ConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Pm10 Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaulPm10ConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultPm10ConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default Ozone Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultOzoneConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ugm3, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(OzoneConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Ozone Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaulOzoneConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ugm3, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultOzoneConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default Radon Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultRadonConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(RadonConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Radon Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaulRadonConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultRadonConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default Nitrogen Dioxide Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     * @returns {ClusterServer} - The default Carbon Monoxide Concentration Measurement Cluster Server.
+     */
+    getDefaultNitrogenDioxideConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ugm3, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        return ClusterServer(NitrogenDioxideConcentrationMeasurementCluster.with('NumericMeasurement'), {
+            measuredValue,
+            minMeasuredValue: null,
+            maxMeasuredValue: null,
+            uncertainty: 0,
+            measurementUnit,
+            measurementMedium,
+        }, {}, {});
+    }
+    /**
+     * Create the default Nitrogen Dioxide Concentration Measurement Cluster Server.
+     *
+     * @param {number} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement.
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The medium of measurement.
+     */
+    createDefaulNitrogenDioxideConcentrationMeasurementClusterServer(measuredValue = 0, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ugm3, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
+        this.addClusterServer(this.getDefaultNitrogenDioxideConcentrationMeasurementClusterServer(measuredValue, measurementUnit, measurementMedium));
+    }
+    /**
+     * Returns the default fan control cluster server rev 2.
+     *
+     * @param fanMode The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @returns The default fan control cluster server.
+     */
+    getDefaultFanControlClusterServer(fanMode = FanControl.FanMode.Off) {
+        return ClusterServer(FanControlCluster.with(FanControl.Feature.MultiSpeed, FanControl.Feature.Auto, FanControl.Feature.Step), {
+            fanMode,
+            fanModeSequence: FanControl.FanModeSequence.OffLowMedHighAuto,
+            percentSetting: 0,
+            percentCurrent: 0,
+            speedMax: 100,
+            speedSetting: 0,
+            speedCurrent: 0,
+        }, {
+            step: async (data) => {
+                this.log.debug('Matter command: step', data.request);
+                await this.commandHandler.executeHandler('step', data);
+            },
+        }, {});
+    }
+    /**
+     * Create the default fan control cluster server rev 2.
+     *
+     * @param fanMode The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @returns The default fan control cluster server.
+     */
+    createDefaultFanControlClusterServer(fanMode = FanControl.FanMode.Off) {
+        this.addClusterServer(this.getDefaultFanControlClusterServer(fanMode));
+    }
+}
+//# sourceMappingURL=matterbridgeEndpoint.js.map