matterbridge 3.0.0-edge.8 → 3.0.0

package/dist/matterbridgeEndpoint.js

@@ -1,10 +1,36 @@
+/**
+ * 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 2.0.0
+ *
+ * Copyright 2024, 2025, 2026 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. *
+ */
+// AnsiLogger module
 import { AnsiLogger, BLUE, CYAN, YELLOW, db, debugStringify, er, hk, or, zb } from './logger/export.js';
+// Matterbridge
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidNumber, isValidObject } from './utils/export.js';
 import { MatterbridgeServer, MatterbridgeServerDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, } from './matterbridgeBehaviors.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, capitalizeFirstLetter, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, } from './matterbridgeEndpointHelpers.js';
+// @matter
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, VendorId } from '@matter/main';
 import { getClusterNameById, MeasurementType } from '@matter/main/types';
+// @matter clusters
 import { Descriptor } from '@matter/main/clusters/descriptor';
 import { PowerSource } from '@matter/main/clusters/power-source';
 import { BridgedDeviceBasicInformation } from '@matter/main/clusters/bridged-device-basic-information';
@@ -27,6 +53,8 @@ import { ElectricalEnergyMeasurement } from '@matter/main/clusters/electrical-en
 import { AirQuality } from '@matter/main/clusters/air-quality';
 import { ConcentrationMeasurement } from '@matter/main/clusters/concentration-measurement';
 import { OccupancySensing } from '@matter/main/clusters/occupancy-sensing';
+import { ThermostatUserInterfaceConfiguration } from '@matter/main/clusters/thermostat-user-interface-configuration';
+// @matter behaviors
 import { DescriptorServer } from '@matter/main/behaviors/descriptor';
 import { PowerSourceServer } from '@matter/main/behaviors/power-source';
 import { BridgedDeviceBasicInformationServer } from '@matter/main/behaviors/bridged-device-basic-information';
@@ -59,9 +87,10 @@ import { FanControlServer } from '@matter/main/behaviors/fan-control';
 import { ResourceMonitoring } from '@matter/main/clusters/resource-monitoring';
 import { HepaFilterMonitoringServer } from '@matter/main/behaviors/hepa-filter-monitoring';
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/main/behaviors/activated-carbon-filter-monitoring';
+import { ThermostatUserInterfaceConfigurationServer } from '@matter/main/behaviors/thermostat-user-interface-configuration';
 export class MatterbridgeEndpoint extends Endpoint {
     static bridgeMode = '';
-    static logLevel = "info";
+    static logLevel = "info" /* LogLevel.INFO */;
     log;
     plugin = undefined;
     configUrl = undefined;
@@ -77,14 +106,25 @@ export class MatterbridgeEndpoint extends Endpoint {
     hardwareVersion = undefined;
     hardwareVersionString = undefined;
     productUrl = 'https://www.npmjs.com/package/matterbridge';
+    // The first device type of the endpoint
     name = undefined;
     deviceType;
     uniqueStorageKey = undefined;
     tagList = undefined;
+    // Maps matter deviceTypes
     deviceTypes = new Map();
+    // Command handler
     commandHandler = new NamedHandler();
+    /**
+     * Represents a MatterbridgeEndpoint.
+     * @constructor
+     * @param {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The DeviceTypeDefinition(s) of the endpoint.
+     * @param {MatterbridgeEndpointOptions} [options={}] - The options for the device.
+     * @param {boolean} [debug=false] - Debug flag.
+     */
     constructor(definition, options = {}, debug = false) {
         let deviceTypeList = [];
+        // Get the first DeviceTypeDefinition
         let firstDefinition;
         if (Array.isArray(definition)) {
             firstDefinition = definition[0];
@@ -97,6 +137,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             firstDefinition = definition;
             deviceTypeList = [{ deviceType: firstDefinition.code, revision: firstDefinition.revision }];
         }
+        // Convert the first DeviceTypeDefinition to an EndpointType.Options
         const deviceTypeDefinitionV8 = {
             name: firstDefinition.name.replace('-', '_'),
             deviceType: firstDefinition.code,
@@ -115,9 +156,11 @@ export class MatterbridgeEndpoint extends Endpoint {
             behaviors: options.tagList ? SupportedBehaviors(DescriptorServer.with(Descriptor.Feature.TagList)) : {},
         };
         const endpointV8 = MutableEndpoint(deviceTypeDefinitionV8);
+        // Check if the uniqueStorageKey is valid
         if (options.uniqueStorageKey && checkNotLatinCharacters(options.uniqueStorageKey)) {
             options.uniqueStorageKey = generateUniqueId(options.uniqueStorageKey);
         }
+        // Convert the options to an Endpoint.Options
         const optionsV8 = {
             id: options.uniqueStorageKey?.replace(/[ .]/g, ''),
             number: options.endpointId,
@@ -135,17 +178,41 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         else
             this.deviceTypes.set(firstDefinition.code, firstDefinition);
-        this.log = new AnsiLogger({ logName: options.uniqueStorageKey ?? 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
+        // console.log('MatterbridgeEndpoint.option', options);
+        // console.log('MatterbridgeEndpoint.endpointV8', endpointV8);
+        // console.log('MatterbridgeEndpoint.optionsV8', optionsV8);
+        // Create the logger
+        this.log = new AnsiLogger({ logName: options.uniqueStorageKey ?? 'MatterbridgeEndpoint', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: debug === true ? "debug" /* LogLevel.DEBUG */ : MatterbridgeEndpoint.logLevel });
         this.log.debug(`${YELLOW}new${db} MatterbridgeEndpoint: ${zb}${'0x' + firstDefinition.code.toString(16).padStart(4, '0')}${db}-${zb}${firstDefinition.name}${db} ` +
             `id: ${CYAN}${options.uniqueStorageKey}${db} number: ${CYAN}${options.endpointId}${db} taglist: ${CYAN}${options.tagList ? debugStringify(options.tagList) : 'undefined'}${db}`);
+        // Add MatterbridgeBehavior with MatterbridgeBehaviorDevice
         this.behaviors.require(MatterbridgeServer, { deviceCommand: new MatterbridgeServerDevice(this.log, this.commandHandler, undefined) });
     }
+    /**
+     * Loads an instance of the MatterbridgeEndpoint class.
+     *
+     * @param {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The DeviceTypeDefinition(s) of the device.
+     * @param {MatterbridgeEndpointOptions} [options={}] - The options for the device.
+     * @param {boolean} [debug=false] - Debug flag.
+     * @returns {Promise<MatterbridgeEndpoint>} MatterbridgeEndpoint instance.
+     */
     static async loadInstance(definition, options = {}, debug = false) {
         return new MatterbridgeEndpoint(definition, options, debug);
     }
+    /**
+     * Get all the device types of this endpoint.
+     *
+     * @returns {DeviceTypeDefinition[]} The device types of this endpoint.
+     */
     getDeviceTypes() {
         return Array.from(this.deviceTypes.values());
     }
+    /**
+     * Checks if the provided cluster server is supported by this endpoint.
+     *
+     * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to check.
+     * @returns {boolean} True if the cluster server is supported, false otherwise.
+     */
     hasClusterServer(cluster) {
         const behavior = getBehavior(this, cluster);
         if (behavior)
@@ -153,6 +220,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         else
             return false;
     }
+    /**
+     * Checks if the provided attribute server is supported for a given cluster of this endpoint.
+     *
+     * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to check.
+     * @param {string} attribute - The attribute name to check.
+     * @returns {boolean} True if the attribute server is supported, false otherwise.
+     */
     hasAttributeServer(cluster, attribute) {
         const behavior = getBehavior(this, cluster);
         if (!behavior || !this.behaviors.supported[behavior.id])
@@ -161,72 +235,186 @@ export class MatterbridgeEndpoint extends Endpoint {
         const defaults = this.behaviors.defaultsFor(behavior);
         return lowercaseFirstLetter(attribute) in options || lowercaseFirstLetter(attribute) in defaults;
     }
+    /**
+     * Retrieves the initial options for the provided cluster server.
+     *
+     * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to get options for.
+     * @returns {Record<string, boolean | number | bigint | string | object | null> | undefined} The options for the provided cluster server, or undefined if the cluster is not supported.
+     */
     getClusterServerOptions(cluster) {
         const behavior = getBehavior(this, cluster);
         if (!behavior)
             return undefined;
         return this.behaviors.optionsFor(behavior);
     }
+    /**
+     * Retrieves the value of the provided attribute from the given cluster.
+     *
+     * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - 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.
+     * @returns {any} The value of the attribute, or undefined if the attribute is not found.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getAttribute(cluster, attribute, log) {
         return getAttribute(this, cluster, attribute, log);
     }
+    /**
+     * Sets the value of an attribute on a cluster server.
+     *
+     * @param {Behavior.Type | ClusterType | ClusterId | string} clusterId - The ID of the cluster.
+     * @param {string} attribute - The name of the attribute.
+     * @param {boolean | number | bigint | string | object | null} value - The value to set for the attribute.
+     * @param {AnsiLogger} [log] - (Optional) The logger to use for logging errors and information.
+     * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the attribute was successfully set.
+     */
     async setAttribute(clusterId, attribute, value, log) {
         return await setAttribute(this, clusterId, attribute, value, log);
     }
+    /**
+     * Update the value of an attribute on a cluster server only if the value is different.
+     *
+     * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to set the attribute on.
+     * @param {string} attribute - The name of the attribute.
+     * @param {boolean | number | bigint | string | object | null} value - The value to set for the attribute.
+     * @param {AnsiLogger} [log] - (Optional) The logger to use for logging the update. Errors are logged to the endpoint logger.
+     * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the attribute was successfully set.
+     */
     async updateAttribute(cluster, attribute, value, log) {
         return await updateAttribute(this, cluster, attribute, value, log);
     }
+    /**
+     * Subscribes to the provided attribute on a cluster.
+     *
+     * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to subscribe the attribute to.
+     * @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 logger for logging errors and information.
+     * @returns {Promise<boolean>} - A boolean indicating whether the subscription was successful.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async subscribeAttribute(cluster, attribute, listener, log) {
         return await subscribeAttribute(this, cluster, attribute, listener, log);
     }
+    /**
+     * Triggers an event on the specified cluster.
+     *
+     * @param {ClusterId} clusterId - The ID of the cluster.
+     * @param {string} event - The name of the event to trigger.
+     * @param {Record<string, boolean | number | bigint | string | object | undefined | null>} payload - The payload to pass to the event.
+     * @param {AnsiLogger} [log] - Optional logger for logging information.
+     * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the event was successfully triggered.
+     */
     async triggerEvent(clusterId, event, payload, log) {
         const clusterName = lowercaseFirstLetter(getClusterNameById(clusterId));
         if (this.construction.status !== Lifecycle.Status.Active) {
             this.log.error(`triggerEvent ${hk}${clusterName}.${event}${er} error: Endpoint ${or}${this.maybeId}${er}:${or}${this.maybeNumber}${er} is in the ${BLUE}${this.construction.status}${er} state`);
             return false;
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const events = this.events;
         if (!(clusterName in events) || !(event in events[clusterName])) {
             this.log.error(`triggerEvent ${hk}${event}${er} error: Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} not found on endpoint ${or}${this.id}${er}:${or}${this.number}${er}`);
             return false;
         }
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
         await this.act((agent) => agent[clusterName].events[event].emit(payload, agent.context));
         log?.info(`${db}Trigger event ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${event}${db} with ${debugStringify(payload)}${db} on endpoint ${or}${this.id}${db}:${or}${this.number}${db} `);
         return true;
     }
+    /**
+     * Adds cluster servers from the provided server list.
+     *
+     * @param {ClusterId[]} serverList - The list of cluster IDs to add.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     addClusterServers(serverList) {
         addClusterServers(this, serverList);
         return this;
     }
+    /**
+     * Adds a fixed label to the FixedLabel cluster. If the cluster server is not present, it will be added.
+     *
+     * @param {string} label - The label to add.
+     * @param {string} value - The value of the label.
+     * @returns {Promise<this>} The current MatterbridgeEndpoint instance for chaining.
+     */
     async addFixedLabel(label, value) {
         await addFixedLabel(this, label, value);
         return this;
     }
+    /**
+     * Adds a user label to the UserLabel cluster. If the cluster server is not present, it will be added.
+     *
+     * @param {string} label - The label to add.
+     * @param {string} value - The value of the label.
+     * @returns {Promise<this>} The current MatterbridgeEndpoint instance for chaining.
+     */
     async addUserLabel(label, value) {
         await addUserLabel(this, label, value);
         return this;
     }
+    /**
+     * Adds a command handler for the specified command.
+     *
+     * @param {keyof MatterbridgeEndpointCommands} command - The command to add the handler for.
+     * @param {HandlerFunction} handler - The handler function to execute when the command is received.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     addCommandHandler(command, handler) {
         this.commandHandler.addHandler(command, handler);
         return this;
     }
+    /**
+     * Execute the command handler for the specified command. Mainly used in Jest tests.
+     *
+     * @param {keyof MatterbridgeEndpointCommands} command - The command to execute.
+     * @param {Record<string, boolean | number | bigint | string | object | null>} request - The optional request to pass to the handler function.
+     * @returns {Promise<void>} A promise that resolves when the command handler has been executed
+     */
     async executeCommandHandler(command, request) {
         await this.commandHandler.executeHandler(command, { request });
     }
+    /**
+     * Adds the required cluster servers (only if they are not present) for the device types of the specified endpoint.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     addRequiredClusterServers() {
         addRequiredClusterServers(this);
         return this;
     }
+    /**
+     * Adds the optional cluster servers (only if they are not present) for the device types of the specified endpoint.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     addOptionalClusterServers() {
         addOptionalClusterServers(this);
         return this;
     }
+    /**
+     * Retrieves all cluster servers.
+     *
+     * @returns {Behavior.Type[]} An array of all cluster servers.
+     */
     getAllClusterServers() {
         return Object.values(this.behaviors.supported);
     }
+    /**
+     * Retrieves the names of all cluster servers.
+     *
+     * @returns {string[]} An array of all cluster server names.
+     */
     getAllClusterServerNames() {
         return Object.keys(this.behaviors.supported);
     }
+    /**
+     * Iterates over each attribute of each cluster server of the device state and calls the provided callback function.
+     *
+     * @param {Function} callback - The callback function to call with the cluster name, cluster id, attribute name, attribute id and attribute value.
+     */
     forEachAttribute(callback) {
         if (!this.lifecycle.isReady || this.construction.status !== Lifecycle.Status.Active)
             return;
@@ -234,16 +422,34 @@ export class MatterbridgeEndpoint extends Endpoint {
             for (const [attributeName, attributeValue] of Object.entries(clusterAttributes)) {
                 const clusterId = getClusterId(this, clusterName);
                 if (clusterId === undefined) {
+                    // this.log.error(`forEachAttribute error: cluster ${clusterName} not found`);
                     continue;
                 }
                 const attributeId = getAttributeId(this, clusterName, attributeName);
                 if (attributeId === undefined) {
+                    // this.log.error(`forEachAttribute error: attribute ${clusterName}.${attributeName} not found`);
                     continue;
                 }
                 callback(clusterName, clusterId, attributeName, attributeId, attributeValue);
             }
         }
     }
+    /**
+     * Adds a child endpoint with the specified device types and options.
+     * If the child endpoint is not already present, it will be created and added.
+     * If the child endpoint is already present, the existing child endpoint will be returned.
+     *
+     * @param {string} endpointName - The name of the new endpoint to add.
+     * @param {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The device types to add.
+     * @param {MatterbridgeEndpointOptions} [options={}] - The options for the endpoint.
+     * @param {boolean} [debug=false] - Whether to enable debug logging.
+     * @returns {MatterbridgeEndpoint} - The child endpoint that was found or added.
+     *
+     * @example
+     * ```typescript
+     * const endpoint = device.addChildDeviceType('Temperature', [temperatureSensor], { tagList: [{ mfgCode: null, namespaceId: LocationTag.Indoor.namespaceId, tag: LocationTag.Indoor.tag, label: null }] }, true);
+     * ```
+     */
     addChildDeviceType(endpointName, definition, options = {}, debug = false) {
         this.log.debug(`addChildDeviceType: ${CYAN}${endpointName}${db}`);
         let alreadyAdded = false;
@@ -283,6 +489,23 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         return child;
     }
+    /**
+     * 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 {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The device types to add.
+     * @param {ClusterId[]} [serverList=[]] - The list of cluster IDs to include.
+     * @param {MatterbridgeEndpointOptions} [options={}] - The options for the device.
+     * @param {boolean} [debug=false] - Whether to enable debug logging.
+     * @returns {MatterbridgeEndpoint} - The child endpoint that was found or added.
+     *
+     * @example
+     * ```typescript
+     * const endpoint = device.addChildDeviceTypeWithClusterServer('Temperature', [temperatureSensor], [], { tagList: [{ mfgCode: null, namespaceId: LocationTag.Indoor.namespaceId, tag: LocationTag.Indoor.tag, label: null }] }, true);
+     * ```
+     */
     addChildDeviceTypeWithClusterServer(endpointName, definition, serverList = [], options = {}, debug = false) {
         this.log.debug(`addChildDeviceTypeWithClusterServer: ${CYAN}${endpointName}${db}`);
         let alreadyAdded = false;
@@ -345,15 +568,38 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         return child;
     }
+    /**
+     * 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) {
         return this.parts.find((part) => part.id === endpointName);
     }
+    /**
+     * Retrieves a child endpoint by its EndpointNumber.
+     *
+     * @param {EndpointNumber} endpointNumber - The EndpointNumber of the endpoint to retrieve.
+     * @returns {MatterbridgeEndpoint | undefined} The child endpoint with the specified EndpointNumber, or undefined if not found.
+     */
     getChildEndpoint(endpointNumber) {
         return this.parts.find((part) => part.number === endpointNumber);
     }
+    /**
+     * Get all the child endpoints of this endpoint.
+     *
+     * @returns {MatterbridgeEndpoint[]} The child endpoints.
+     */
     getChildEndpoints() {
         return Array.from(this.parts);
     }
+    /**
+     * Serializes the Matterbridge device into a serialized object.
+     *
+     * @param pluginName - The name of the plugin.
+     * @returns The serialized Matterbridge device object.
+     */
     static serialize(device) {
         if (!device.serialNumber || !device.deviceName || !device.uniqueId)
             return;
@@ -376,9 +622,15 @@ export class MatterbridgeEndpoint extends Endpoint {
                 serialized.clusterServersId.push(BridgedDeviceBasicInformation.Cluster.id);
             if (behaviorName === 'powerSource')
                 serialized.clusterServersId.push(PowerSource.Cluster.id);
+            // serialized.clusterServersId.push(this.behaviors.supported[behaviorName]cluster.id);
         });
         return serialized;
     }
+    /**
+     * Deserializes the device into a serialized object.
+     *
+     * @returns The deserialized MatterbridgeDevice.
+     */
     static deserialize(serializedDevice) {
         const device = new MatterbridgeEndpoint(serializedDevice.deviceTypes, { uniqueStorageKey: serializedDevice.endpointName, endpointId: serializedDevice.endpoint }, false);
         device.plugin = serializedDevice.pluginName;
@@ -394,9 +646,16 @@ export class MatterbridgeEndpoint extends Endpoint {
                 device.createDefaultBridgedDeviceBasicInformationClusterServer(serializedDevice.deviceName, serializedDevice.serialNumber, serializedDevice.vendorId ?? 0xfff1, serializedDevice.vendorName ?? 'Matterbridge', serializedDevice.productName ?? 'Matterbridge device');
             else if (clusterId === PowerSource.Cluster.id)
                 device.createDefaultPowerSourceWiredClusterServer();
+            // else addClusterServerFromList(device, [clusterId]);
         }
         return device;
     }
+    /**
+     * Creates a default power source wired cluster server.
+     *
+     * @param wiredCurrentType - The type of wired current (default: PowerSource.WiredCurrentType.Ac)
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultPowerSourceWiredClusterServer(wiredCurrentType = PowerSource.WiredCurrentType.Ac) {
         this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Wired), {
             wiredCurrentType,
@@ -407,6 +666,16 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * 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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1) {
         this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), {
             status: PowerSource.PowerSourceStatus.Active,
@@ -424,6 +693,14 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * 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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500) {
         this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), {
             status: PowerSource.PowerSourceStatus.Active,
@@ -442,6 +719,21 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default Basic Information Cluster Server for the server node.
+     *
+     * @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'.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productId, productName, softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
         this.log.logName = deviceName;
         this.deviceName = deviceName;
@@ -465,6 +757,20 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         return this;
     }
+    /**
+     * Creates a default BridgedDeviceBasicInformationClusterServer for the aggregator endpoints.
+     *
+     * @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'.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber, vendorId, vendorName, productName, softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
         this.log.logName = deviceName;
         this.deviceName = deviceName;
@@ -481,7 +787,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.behaviors.require(BridgedDeviceBasicInformationServer.enable({
             events: { leave: true, reachableChanged: true },
         }), {
-            vendorId: vendorId !== undefined ? VendorId(vendorId) : undefined,
+            vendorId: vendorId !== undefined ? VendorId(vendorId) : undefined, // 4874
             vendorName: vendorName.slice(0, 32),
             productName: productName.slice(0, 32),
             productUrl: this.productUrl,
@@ -497,6 +803,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default identify cluster server with the specified identify time and type.
+     *
+     * @param {number} [identifyTime=0] - The time to identify the server. Defaults to 0.
+     * @param {Identify.IdentifyType} [identifyType=Identify.IdentifyType.None] - The type of identification. Defaults to Identify.IdentifyType.None.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultIdentifyClusterServer(identifyTime = 0, identifyType = Identify.IdentifyType.None) {
         this.behaviors.require(MatterbridgeIdentifyServer, {
             identifyTime,
@@ -504,14 +817,32 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default groups cluster server.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultGroupsClusterServer() {
         this.behaviors.require(GroupsServer);
         return this;
     }
+    /**
+     * Creates a default scenes management cluster server.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultScenesClusterServer() {
         this.behaviors.require(ScenesManagementServer);
         return this;
     }
+    /**
+     * Creates a default OnOff cluster server for light devices.
+     *
+     * @param {boolean} [onOff=false] - The initial state of the OnOff cluster.
+     * @param {boolean} [globalSceneControl=false] - The global scene control state.
+     * @param {number} [onTime=0] - The on time value.
+     * @param {number} [offWaitTime=0] - The off wait time value.
+     * @param {OnOff.StartUpOnOff | null} [startUpOnOff=null] - The start-up OnOff state. Null means previous state.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultOnOffClusterServer(onOff = false, globalSceneControl = false, onTime = 0, offWaitTime = 0, startUpOnOff = null) {
         this.behaviors.require(MatterbridgeOnOffServer.with(OnOff.Feature.Lighting), {
             onOff,
@@ -522,24 +853,52 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates an OnOff cluster server without features.
+     *
+     * @param {boolean} [onOff=false] - The initial state of the OnOff cluster.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createOnOffClusterServer(onOff = false) {
         this.behaviors.require(MatterbridgeOnOffServer, {
             onOff,
         });
         return this;
     }
+    /**
+     * Creates a DeadFront OnOff cluster server.
+     *
+     * @param {boolean} [onOff=false] - The initial state of the OnOff cluster.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDeadFrontOnOffClusterServer(onOff = false) {
         this.behaviors.require(MatterbridgeOnOffServer.with(OnOff.Feature.DeadFrontBehavior), {
             onOff,
         });
         return this;
     }
+    /**
+     * Creates an OffOnly OnOff cluster server.
+     *
+     * @param {boolean} [onOff=false] - The initial state of the OnOff cluster.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createOffOnlyOnOffClusterServer(onOff = false) {
         this.behaviors.require(MatterbridgeOnOffServer.with(OnOff.Feature.OffOnly), {
             onOff,
         });
         return this;
     }
+    /**
+     * Creates a default level control cluster server for light devices.
+     *
+     * @param {number} [currentLevel=254] - The current level (default: 254).
+     * @param {number} [minLevel=1] - The minimum level (default: 1).
+     * @param {number} [maxLevel=254] - The maximum level (default: 254).
+     * @param {number | null} [onLevel=null] - The on level (default: null).
+     * @param {number | null} [startUpCurrentLevel=null] - The startUp on level (default: null).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 1, maxLevel = 254, onLevel = null, startUpCurrentLevel = null) {
         this.behaviors.require(MatterbridgeLevelControlServer.with(LevelControl.Feature.OnOff, LevelControl.Feature.Lighting), {
             currentLevel,
@@ -555,6 +914,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a level control cluster server without features.
+     *
+     * @param {number} [currentLevel=254] - The current level (default: 254).
+     * @param {number | null} [onLevel=null] - The on level (default: null).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createLevelControlClusterServer(currentLevel = 254, onLevel = null) {
         this.behaviors.require(MatterbridgeLevelControlServer, {
             currentLevel,
@@ -566,6 +932,18 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default color control cluster server with Xy, HueSaturation and ColorTemperature.
+     *
+     * @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.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultColorControlClusterServer(currentX = 0, currentY = 0, currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
@@ -588,6 +966,19 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a Xy color control cluster server with Xy and ColorTemperature.
+     *
+     * @param currentX - The current X value.
+     * @param currentY - The current Y 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.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * From zigbee to matter = Math.max(Math.min(Math.round(x * 65536), 65279), 0)
+     */
     createXyColorControlClusterServer(currentX = 0, currentY = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentXAndCurrentY,
@@ -608,6 +999,16 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default hue and saturation control cluster server with HueSaturation and ColorTemperature.
+     *
+     * @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.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createHsColorControlClusterServer(currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
@@ -628,6 +1029,14 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a color temperature color control cluster server.
+     *
+     * @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.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createCtColorControlClusterServer(colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
@@ -646,12 +1055,23 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Configures the color control mode for the device.
+     *
+     * @param {ColorControl.ColorMode} colorMode - The color mode to set.
+     */
     async configureColorControlMode(colorMode) {
         if (isValidNumber(colorMode, ColorControl.ColorMode.CurrentHueAndCurrentSaturation, ColorControl.ColorMode.ColorTemperatureMireds)) {
             await this.setAttribute(ColorControl.Cluster.id, 'colorMode', colorMode, this.log);
             await this.setAttribute(ColorControl.Cluster.id, 'enhancedColorMode', colorMode, this.log);
         }
     }
+    /**
+     * Creates a default window covering cluster server (Lift and PositionAwareLift).
+     *
+     * @param positionPercent100ths - The position percentage in 100ths (0-10000). Defaults to 0. Matter uses 10000 = fully closed 0 = fully opened.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultWindowCoveringClusterServer(positionPercent100ths) {
         this.behaviors.require(MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift), {
             type: WindowCovering.WindowCoveringType.Rollershade,
@@ -667,11 +1087,15 @@ export class MatterbridgeEndpoint extends Endpoint {
             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,
-            currentPositionLiftPercent100ths: positionPercent100ths ?? 0,
+            targetPositionLiftPercent100ths: positionPercent100ths ?? 0, // 0 Fully open 10000 fully closed
+            currentPositionLiftPercent100ths: positionPercent100ths ?? 0, // 0 Fully open 10000 fully closed
         });
         return this;
     }
+    /**
+     * Sets the window covering target position as the current position and stops the movement.
+     *
+     */
     async setWindowCoveringTargetAsCurrentAndStopped() {
         const position = this.getAttribute(WindowCovering.Cluster.id, 'currentPositionLiftPercent100ths', this.log);
         if (isValidNumber(position, 0, 10000)) {
@@ -684,6 +1108,12 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         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.
+     */
     async setWindowCoveringCurrentTargetStatus(current, target, status) {
         await this.setAttribute(WindowCovering.Cluster.id, 'currentPositionLiftPercent100ths', current, this.log);
         await this.setAttribute(WindowCovering.Cluster.id, 'targetPositionLiftPercent100ths', target, this.log);
@@ -694,6 +1124,10 @@ export class MatterbridgeEndpoint extends Endpoint {
         }, this.log);
         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.
+     */
     async setWindowCoveringStatus(status) {
         await this.setAttribute(WindowCovering.Cluster.id, 'operationalStatus', {
             global: status,
@@ -702,6 +1136,11 @@ export class MatterbridgeEndpoint extends Endpoint {
         }, this.log);
         this.log.debug(`Set WindowCovering operationalStatus: ${status}`);
     }
+    /**
+     * Retrieves the status of the window covering.
+     *
+     * @returns The global operational status of the window covering or undefined.
+     */
     getWindowCoveringStatus() {
         const status = this.getAttribute(WindowCovering.Cluster.id, 'operationalStatus', this.log);
         if (isValidObject(status, 3) && 'global' in status && typeof status.global === 'number') {
@@ -709,36 +1148,66 @@ export class MatterbridgeEndpoint extends Endpoint {
             return status.global;
         }
     }
+    /**
+     * Sets the target and current position of the window covering.
+     *
+     * @param position - The position to set, specified as a number.
+     */
     async setWindowCoveringTargetAndCurrentPosition(position) {
         await this.setAttribute(WindowCovering.Cluster.id, 'currentPositionLiftPercent100ths', position, this.log);
         await this.setAttribute(WindowCovering.Cluster.id, 'targetPositionLiftPercent100ths', position, this.log);
         this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths: ${position} and targetPositionLiftPercent100ths: ${position}.`);
     }
+    /**
+     * Creates a default thermostat cluster server with Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode.
+     *
+     * @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 {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 1, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50) {
         this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode), {
             localTemperature: localTemperature * 100,
             systemMode: Thermostat.SystemMode.Auto,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingAndHeating,
+            // Thermostat.Feature.Heating
             occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
             minHeatSetpointLimit: minHeatSetpointLimit * 100,
             maxHeatSetpointLimit: maxHeatSetpointLimit * 100,
             absMinHeatSetpointLimit: minHeatSetpointLimit * 100,
             absMaxHeatSetpointLimit: maxHeatSetpointLimit * 100,
+            // Thermostat.Feature.Cooling
             occupiedCoolingSetpoint: occupiedCoolingSetpoint * 100,
             minCoolSetpointLimit: minCoolSetpointLimit * 100,
             maxCoolSetpointLimit: maxCoolSetpointLimit * 100,
             absMinCoolSetpointLimit: minCoolSetpointLimit * 100,
             absMaxCoolSetpointLimit: maxCoolSetpointLimit * 100,
+            // Thermostat.Feature.AutoMode
             minSetpointDeadBand: minSetpointDeadBand * 100,
             thermostatRunningMode: Thermostat.ThermostatRunningMode.Off,
         });
         return this;
     }
+    /**
+     * Creates a default heating thermostat cluster server with Thermostat.Feature.Heating.
+     * @param {number} [localTemperature] - The local temperature value in degrees Celsius. Defaults to 23°.
+     * @param {number} [occupiedHeatingSetpoint] - The occupied heating setpoint value in degrees Celsius. Defaults to 21°.
+     * @param {number} [minHeatSetpointLimit] - The minimum heat setpoint limit value. Defaults to 0°.
+     * @param {number} [maxHeatSetpointLimit] - The maximum heat setpoint limit value. Defaults to 50°.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultHeatingThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50) {
         this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating), {
             localTemperature: localTemperature * 100,
             systemMode: Thermostat.SystemMode.Heat,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.HeatingOnly,
+            // Thermostat.Feature.Heating
             occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
             minHeatSetpointLimit: minHeatSetpointLimit * 100,
             maxHeatSetpointLimit: maxHeatSetpointLimit * 100,
@@ -747,11 +1216,20 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default cooling thermostat cluster server with Thermostat.Feature.Cooling.
+     * @param {number} [localTemperature] - The local temperature value in degrees Celsius. Defaults to 23°.
+     * @param {number} [occupiedCoolingSetpoint] - The occupied cooling setpoint value in degrees Celsius. Defaults to 25°.
+     * @param {number} [minCoolSetpointLimit] - The minimum cool setpoint limit value. Defaults to 0°.
+     * @param {number} [maxCoolSetpointLimit] - The maximum cool setpoint limit value. Defaults to 50°.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultCoolingThermostatClusterServer(localTemperature = 23, occupiedCoolingSetpoint = 25, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50) {
         this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Cooling), {
             localTemperature: localTemperature * 100,
             systemMode: Thermostat.SystemMode.Cool,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingOnly,
+            // Thermostat.Feature.Cooling
             occupiedCoolingSetpoint: occupiedCoolingSetpoint * 100,
             minCoolSetpointLimit: minCoolSetpointLimit * 100,
             maxCoolSetpointLimit: maxCoolSetpointLimit * 100,
@@ -760,6 +1238,29 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default thermostat user interface configuration cluster server.
+     *
+     * @remarks
+     * The default values are:
+     * - temperatureDisplayMode: ThermostatUserInterfaceConfiguration.TemperatureDisplayMode.Celsius (writeble).
+     * - keypadLockout: ThermostatUserInterfaceConfiguration.KeypadLockout.NoLockout (writeble).
+     * - scheduleProgrammingVisibility: ThermostatUserInterfaceConfiguration.ScheduleProgrammingVisibility.ScheduleProgrammingPermitted (writeble).
+     */
+    createDefaultThermostatUserInterfaceConfigurationClusterServer() {
+        this.behaviors.require(ThermostatUserInterfaceConfigurationServer, {
+            temperatureDisplayMode: ThermostatUserInterfaceConfiguration.TemperatureDisplayMode.Celsius,
+            keypadLockout: ThermostatUserInterfaceConfiguration.KeypadLockout.NoLockout,
+            scheduleProgrammingVisibility: ThermostatUserInterfaceConfiguration.ScheduleProgrammingVisibility.ScheduleProgrammingPermitted,
+        });
+        return this;
+    }
+    /**
+     * Creates a default fan control cluster server.
+     *
+     * @param fanMode The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultFanControlClusterServer(fanMode = FanControl.FanMode.Off) {
         this.behaviors.require(MatterbridgeFanControlServer.with(FanControl.Feature.MultiSpeed, FanControl.Feature.Auto, FanControl.Feature.Step), {
             fanMode,
@@ -772,6 +1273,12 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a base fan control cluster server.
+     *
+     * @param fanMode The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createBaseFanControlClusterServer(fanMode = FanControl.FanMode.Off) {
         this.behaviors.require(FanControlServer, {
             fanMode,
@@ -781,33 +1288,82 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default HEPA Filter Monitoring Cluster Server.
+     * It supports ResourceMonitoring.Feature.Condition and ResourceMonitoring.Feature.ReplacementProductList.
+     *
+     * @param {ResourceMonitoring.ChangeIndication} changeIndication - The initial change indication. Default is ResourceMonitoring.ChangeIndication.Ok.
+     * @param {boolean | undefined} inPlaceIndicator - The in-place indicator. Default is undefined.
+     * @param {number | undefined} lastChangedTime - The last changed time (EpochS). Default is undefined.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultHepaFilterMonitoringClusterServer(changeIndication = ResourceMonitoring.ChangeIndication.Ok, inPlaceIndicator = undefined, lastChangedTime = undefined) {
-        this.behaviors.require(HepaFilterMonitoringServer, {
+        this.behaviors.require(HepaFilterMonitoringServer.with(ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.ReplacementProductList), {
+            condition: 100, // Feature.Condition
+            degradationDirection: ResourceMonitoring.DegradationDirection.Down, // Feature.Condition
             changeIndication,
             inPlaceIndicator,
             lastChangedTime,
+            replacementProductList: [], // Feature.ReplacementProductList
         });
         return this;
     }
+    /**
+     * Creates a default Activated Carbon Filter Monitoring Cluster Server.
+     * It supports ResourceMonitoring.Feature.Condition and ResourceMonitoring.Feature.ReplacementProductList.
+     *
+     * @param {ResourceMonitoring.ChangeIndication} changeIndication - The initial change indication. Default is ResourceMonitoring.ChangeIndication.Ok.
+     * @param {boolean | undefined} inPlaceIndicator - The in-place indicator. Default is undefined.
+     * @param {number | undefined} lastChangedTime - The last changed time (EpochS). Default is undefined.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultActivatedCarbonFilterMonitoringClusterServer(changeIndication = ResourceMonitoring.ChangeIndication.Ok, inPlaceIndicator = undefined, lastChangedTime = undefined) {
-        this.behaviors.require(ActivatedCarbonFilterMonitoringServer, {
+        this.behaviors.require(ActivatedCarbonFilterMonitoringServer.with(ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.ReplacementProductList), {
+            condition: 100, // Feature.Condition
+            degradationDirection: ResourceMonitoring.DegradationDirection.Down, // Feature.Condition
             changeIndication,
             inPlaceIndicator,
             lastChangedTime,
+            replacementProductList: [], // Feature.ReplacementProductList
         });
         return this;
     }
+    /**
+     * Creates a default door lock cluster server.
+     *
+     * @param {DoorLock.LockState} [lockState=DoorLock.LockState.Locked] - The initial state of the lock (default: Locked).
+     * @param {DoorLock.LockType} [lockType=DoorLock.LockType.DeadBolt] - The type of the lock (default: DeadBolt).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * All operating modes NOT supported by a lock SHALL be set to one. The value of the OperatingMode enumeration defines the related bit to be set.
+     */
     createDefaultDoorLockClusterServer(lockState = DoorLock.LockState.Locked, lockType = DoorLock.LockType.DeadBolt) {
         this.behaviors.require(MatterbridgeDoorLockServer.enable({ events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true } }), {
             lockState,
             lockType,
             actuatorEnabled: false,
             operatingMode: DoorLock.OperatingMode.Normal,
+            // Special case of inverted bitmap: add also alwaysSet = 2047
             supportedOperatingModes: { normal: false, vacation: true, privacy: true, noRemoteLockUnlock: true, passage: true, alwaysSet: 2047 },
             alarmMask: { lockJammed: false, lockFactoryReset: false, lockRadioPowerCycled: false, wrongCodeEntryLimit: false, frontEscutcheonRemoved: false, doorForcedOpen: false },
         });
         return this;
     }
+    /**
+     * Creates a default Mode Select cluster server.
+     *
+     * @param {string} description - The description of the mode select cluster.
+     * @param {ModeSelect.ModeOption[]} supportedModes - The list of supported modes.
+     * @param {number} [currentMode=0] - The current mode (default: 0).
+     * @param {number} [startUpMode=0] - The startup mode (default: 0).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * endpoint.createDefaultModeSelectClusterServer('Night mode', [{ label: 'Led ON', mode: 0, semanticTags: [] }, { label: 'Led OFF', mode: 1, semanticTags: [] }], 0, 0);
+     */
     createDefaultModeSelectClusterServer(description, supportedModes, currentMode = 0, startUpMode = 0) {
         this.behaviors.require(MatterbridgeModeSelectServer, {
             description: description,
@@ -818,6 +1374,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates the default Valve Configuration And Control cluster server.
+     *
+     * @param {ValveConfigurationAndControl.ValveState} [valveState=ValveConfigurationAndControl.ValveState.Closed] - The valve state to set. Defaults to `ValveConfigurationAndControl.ValveState.Closed`.
+     * @param {number} [valveLevel=0] - The valve level to set. Defaults to 0.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultValveConfigurationAndControlClusterServer(valveState = ValveConfigurationAndControl.ValveState.Closed, valveLevel = 0) {
         this.behaviors.require(MatterbridgeValveConfigurationAndControlServer.with(ValveConfigurationAndControl.Feature.Level), {
             currentState: valveState,
@@ -833,6 +1396,12 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates the default PumpConfigurationAndControl cluster server.
+     *
+     * @param {PumpConfigurationAndControl.OperationMode} [pumpMode=PumpConfigurationAndControl.OperationMode.Normal] - The pump mode to set. Defaults to `PumpConfigurationAndControl.OperationMode.Normal`.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultPumpConfigurationAndControlClusterServer(pumpMode = PumpConfigurationAndControl.OperationMode.Normal) {
         this.behaviors.require(PumpConfigurationAndControlServer.with(PumpConfigurationAndControl.Feature.ConstantSpeed), {
             minConstSpeed: null,
@@ -847,6 +1416,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates the default SmokeCOAlarm Cluster Server.
+     *
+     * @param {SmokeCoAlarm.AlarmState} smokeState - The state of the smoke alarm. Defaults to SmokeCoAlarm.AlarmState.Normal.
+     * @param {SmokeCoAlarm.AlarmState} coState - The state of the CO alarm. Defaults to SmokeCoAlarm.AlarmState.Normal.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultSmokeCOAlarmClusterServer(smokeState = SmokeCoAlarm.AlarmState.Normal, coState = SmokeCoAlarm.AlarmState.Normal) {
         this.behaviors.require(MatterbridgeSmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm).enable({
             events: { smokeAlarm: true, interconnectSmokeAlarm: false, coAlarm: true, interconnectCoAlarm: false, lowBattery: true, hardwareFault: true, endOfService: true, selfTestComplete: true, alarmMuted: true, muteEnded: true, allClear: true },
@@ -862,6 +1438,12 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a smoke only SmokeCOAlarm Cluster Server.
+     *
+     * @param {SmokeCoAlarm.AlarmState} smokeState - The state of the smoke alarm. Defaults to SmokeCoAlarm.AlarmState.Normal.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createSmokeOnlySmokeCOAlarmClusterServer(smokeState = SmokeCoAlarm.AlarmState.Normal) {
         this.behaviors.require(MatterbridgeSmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm).enable({
             events: { smokeAlarm: true, interconnectSmokeAlarm: false, coAlarm: false, interconnectCoAlarm: false, lowBattery: true, hardwareFault: true, endOfService: true, selfTestComplete: true, alarmMuted: true, muteEnded: true, allClear: true },
@@ -876,6 +1458,12 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a co only SmokeCOAlarm Cluster Server.
+     *
+     * @param {SmokeCoAlarm.AlarmState} coState - The state of the CO alarm. Defaults to SmokeCoAlarm.AlarmState.Normal.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createCoOnlySmokeCOAlarmClusterServer(coState = SmokeCoAlarm.AlarmState.Normal) {
         this.behaviors.require(MatterbridgeSmokeCoAlarmServer.with(SmokeCoAlarm.Feature.CoAlarm).enable({
             events: { smokeAlarm: false, interconnectSmokeAlarm: false, coAlarm: true, interconnectCoAlarm: false, lowBattery: true, hardwareFault: true, endOfService: true, selfTestComplete: true, alarmMuted: true, muteEnded: true, allClear: true },
@@ -890,6 +1478,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default momentary switch cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server with default momentary switch features and configuration suitable for (AppleHome) Single Double Long automations.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultSwitchClusterServer() {
         this.behaviors.require(MatterbridgeSwitchServer.with(Switch.Feature.MomentarySwitch, Switch.Feature.MomentarySwitchRelease, Switch.Feature.MomentarySwitchLongPress, Switch.Feature.MomentarySwitchMultiPress).enable({
             events: { initialPress: true, longPress: true, shortRelease: true, longRelease: true, multiPressOngoing: true, multiPressComplete: true },
@@ -900,6 +1495,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default latching switch cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server with default latching switch features and configuration suitable for a latching switch with 2 positions.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultLatchingSwitchClusterServer() {
         this.behaviors.require(SwitchServer.with(Switch.Feature.LatchingSwitch).enable({
             events: { switchLatched: true },
@@ -909,6 +1511,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * 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 {boolean} - A boolean indicating whether the event was successfully triggered.
+     */
     async triggerSwitchEvent(event, log) {
         if (this.maybeNumber === undefined) {
             this.log.error(`triggerSwitchEvent ${event} error: Endpoint number not assigned on endpoint ${this.maybeId}:${this.maybeNumber}`);
@@ -968,6 +1577,18 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         return true;
     }
+    /**
+     * Creates a default boolean state cluster server.
+     *
+     * @param {boolean} contact - The state of the cluster. Defaults to true (true = contact).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * Water Leak Detector: true = leak, false = no leak
+     * Water Freeze Detector: true = freeze, false = no freeze
+     * Rain Sensor: true = rain, false = no rain
+     * Contact Sensor: true = closed or contact, false = open or no contact
+     */
     createDefaultBooleanStateClusterServer(contact) {
         this.behaviors.require(BooleanStateServer.enable({
             events: { stateChange: true },
@@ -976,6 +1597,18 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default boolean state configuration cluster server to be used with the waterFreezeDetector, waterLeakDetector, and rainSensor device types.
+     *
+     * @remarks Supports the enableDisableAlarm command.
+     *
+     * @param {boolean} [sensorFault=false] - Optional boolean value indicating the sensor fault state. Defaults to `false` if not provided.
+     * @param {number} [currentSensitivityLevel=0] - The current sensitivity level. Defaults to `0` if not provided.
+     * @param {number} [supportedSensitivityLevels=2] - The number of supported sensitivity levels. Defaults to `2` if not provided (min 2, max 10).
+     * @param {number} [defaultSensitivityLevel=0] - The default sensitivity level. Defaults to `0` if not provided.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     */
     createDefaultBooleanStateConfigurationClusterServer(sensorFault = false, currentSensitivityLevel = 0, supportedSensitivityLevels = 2, defaultSensitivityLevel = 0) {
         this.behaviors.require(MatterbridgeBooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel).enable({
             events: { alarmsStateChanged: true, sensorFault: true },
@@ -990,10 +1623,21 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default Power Topology Cluster Server with feature TreeTopology. Only needed for an electricalSensor device type.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultPowerTopologyClusterServer() {
         this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.TreeTopology));
         return this;
     }
+    /**
+     * Creates a default Electrical Energy Measurement Cluster Server.
+     *
+     * @param {number} energy - The total consumption value in mW/h.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultElectricalEnergyMeasurementClusterServer(energy = null) {
         this.behaviors.require(ElectricalEnergyMeasurementServer.with(ElectricalEnergyMeasurement.Feature.ImportedEnergy, ElectricalEnergyMeasurement.Feature.ExportedEnergy, ElectricalEnergyMeasurement.Feature.CumulativeEnergy), {
             accuracy: {
@@ -1009,6 +1653,15 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates 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 {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultElectricalPowerMeasurementClusterServer(voltage = null, current = null, power = null, frequency = null) {
         this.behaviors.require(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), {
             powerMode: ElectricalPowerMeasurement.PowerMode.Ac,
@@ -1050,36 +1703,113 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default TemperatureMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the temperature x 100.
+     * @param {number | null} minMeasuredValue - The minimum measured value of the temperature x 100.
+     * @param {number | null} maxMeasuredValue - The maximum measured value of the temperature x 100.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
         this.behaviors.require(TemperatureMeasurementServer, getDefaultTemperatureMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
         return this;
     }
+    /**
+     * Creates a default RelativeHumidityMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the relative humidity x 100.
+     * @param {number | null} minMeasuredValue - The minimum measured value of the relative humidity x 100.
+     * @param {number | null} maxMeasuredValue - The maximum measured value of the relative humidity x 100.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultRelativeHumidityMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
         this.behaviors.require(RelativeHumidityMeasurementServer, getDefaultRelativeHumidityMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
         return this;
     }
+    /**
+     * Creates a default PressureMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value for the pressure.
+     * @param {number | null} minMeasuredValue - The minimum measured value for the pressure.
+     * @param {number | null} maxMeasuredValue - The maximum measured value for the pressure.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultPressureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
         this.behaviors.require(PressureMeasurementServer, getDefaultPressureMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
         return this;
     }
+    /**
+     * Creates a default IlluminanceMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of illuminance.
+     * @param {number | null} minMeasuredValue - The minimum measured value of illuminance.
+     * @param {number | null} maxMeasuredValue - The maximum measured value of illuminance.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remark The default value for the illuminance measurement is null.
+     * This attribute SHALL indicate the illuminance in Lux (symbol lx) as follows:
+     * •  MeasuredValue = 10,000 x log10(illuminance) + 1,
+     *    where 1 lx <= illuminance <= 3.576 Mlx, corresponding to a MeasuredValue in the range 1 to 0xFFFE.
+     * • 0 indicates a value of illuminance that is too low to be measured
+     * • null indicates that the illuminance measurement is invalid.
+     *
+     * @remarks
+     * Lux to matter = Math.round(Math.max(Math.min(10000 * Math.log10(lux), 0xfffe), 0))
+     * Matter to Lux = Math.round(Math.max(Math.pow(10, value / 10000), 0))
+     */
     createDefaultIlluminanceMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
         this.behaviors.require(IlluminanceMeasurementServer, getDefaultIlluminanceMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
         return this;
     }
+    /**
+     * Creates a default FlowMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the flow in 10 x m3/h.
+     * @param {number | null} minMeasuredValue - The minimum measured value of the flow in 10 x m3/h.
+     * @param {number | null} maxMeasuredValue - The maximum measured value of the flow in 10 x m3/h.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultFlowMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
         this.behaviors.require(FlowMeasurementServer, getDefaultFlowMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
         return this;
     }
+    /**
+     * Creates a default OccupancySensing cluster server.
+     *
+     * @param {boolean} occupied - A boolean indicating whether the occupancy is occupied or not. Default is false.
+     * @param {number} holdTime - The hold time in seconds. Default is 30.
+     * @param {number} holdTimeMin - The minimum hold time in seconds. Default is 1.
+     * @param {number} holdTimeMax - The maximum hold time in seconds. Default is 300.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remark The default value for the occupancy sensor type is PIR.
+     */
     createDefaultOccupancySensingClusterServer(occupied = false, holdTime = 30, holdTimeMin = 1, holdTimeMax = 300) {
         this.behaviors.require(OccupancySensingServer.with(OccupancySensing.Feature.PassiveInfrared), getDefaultOccupancySensingClusterServer(occupied, holdTime, holdTimeMin, holdTimeMax));
         return this;
     }
+    /**
+     * Creates a default AirQuality cluster server.
+     *
+     * @param {AirQuality.AirQualityEnum} airQuality The air quality level. Defaults to `AirQuality.AirQualityType.Unknown`.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultAirQualityClusterServer(airQuality = AirQuality.AirQualityEnum.Unknown) {
         this.behaviors.require(AirQualityServer.with(AirQuality.Feature.Fair, AirQuality.Feature.Moderate, AirQuality.Feature.VeryPoor, AirQuality.Feature.ExtremelyPoor), {
             airQuality,
         });
         return this;
     }
+    /**
+     * Creates a default TotalVolatileOrganicCompoundsConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ppm).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     * @param {number} [uncertainty] - The uncertainty value (optional).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultTvocMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air, uncertainty) {
         this.behaviors.require(TotalVolatileOrganicCompoundsConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1091,6 +1821,11 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * @param {ConcentrationMeasurement.LevelValue} levelValue - The level value of the measurement (default to ConcentrationMeasurement.LevelValue.Unknown).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The measurement medium (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createLevelTvocMeasurementClusterServer(levelValue = ConcentrationMeasurement.LevelValue.Unknown, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(TotalVolatileOrganicCompoundsConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.LevelIndication, ConcentrationMeasurement.Feature.MediumLevel, ConcentrationMeasurement.Feature.CriticalLevel), {
             levelValue,
@@ -1098,6 +1833,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default CarbonMonoxideConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ppm).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultCarbonMonoxideConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(CarbonMonoxideConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1109,6 +1851,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default CarbonDioxideConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ppm).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultCarbonDioxideConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(CarbonDioxideConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1120,6 +1869,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default FormaldehydeConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ppm).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultFormaldehydeConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(FormaldehydeConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1131,6 +1887,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default Pm1ConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ppm).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultPm1ConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(Pm1ConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1142,6 +1905,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default Pm25ConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ppm).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultPm25ConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(Pm25ConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1153,6 +1923,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default Pm10ConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ppm).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultPm10ConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(Pm10ConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1164,6 +1941,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default OzoneConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ugm3).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultOzoneConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ugm3, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(OzoneConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1175,6 +1959,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default RadonConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ppm).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultRadonConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(RadonConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1186,6 +1977,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default NitrogenDioxideConcentrationMeasurement cluster server.
+     *
+     * @param {number | null} measuredValue - The measured value of the concentration.
+     * @param {ConcentrationMeasurement.MeasurementUnit} measurementUnit - The unit of measurement (default to ConcentrationMeasurement.MeasurementUnit.Ugm3).
+     * @param {ConcentrationMeasurement.MeasurementMedium} measurementMedium - The unit of measurement (default to ConcentrationMeasurement.MeasurementMedium.Air).
+     */
     createDefaultNitrogenDioxideConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ugm3, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(NitrogenDioxideConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1198,3 +1996,4 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
 }
+//# sourceMappingURL=matterbridgeEndpoint.js.map