matterbridge 3.1.8-dev-20250727-662308b → 3.1.8

package/dist/matterbridgeEndpoint.js

@@ -1,5 +1,30 @@
+/**
+ * This file contains the class MatterbridgeEndpoint that extends the Endpoint class from the Matter.js library.
+ *
+ * @file matterbridgeEndpoint.ts
+ * @author Luca Liguori
+ * @created 2024-10-01
+ * @version 2.1.1
+ * @license Apache-2.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.
+ */
+// @matter
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, UINT16_MAX, UINT32_MAX, 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';
@@ -26,6 +51,7 @@ import { ThermostatUserInterfaceConfiguration } from '@matter/main/clusters/ther
 import { OperationalState } from '@matter/main/clusters/operational-state';
 import { DeviceEnergyManagement } from '@matter/main/clusters/device-energy-management';
 import { DeviceEnergyManagementMode } from '@matter/main/clusters/device-energy-management-mode';
+// @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';
@@ -57,18 +83,39 @@ import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@ma
 import { FanControlServer } from '@matter/main/behaviors/fan-control';
 import { ResourceMonitoring } from '@matter/main/clusters/resource-monitoring';
 import { ThermostatUserInterfaceConfigurationServer } from '@matter/main/behaviors/thermostat-user-interface-configuration';
+// AnsiLogger module
 import { AnsiLogger, CYAN, YELLOW, db, debugStringify, hk, or, zb } from './logger/export.js';
+// Matterbridge
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidNumber, isValidObject, isValidString } from './utils/export.js';
 import { MatterbridgeServer, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeHepaFilterMonitoringServer, } from './matterbridgeBehaviors.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultOperationalStateClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, invokeBehaviorCommand, triggerEvent, featuresFor, } from './matterbridgeEndpointHelpers.js';
 export class MatterbridgeEndpoint extends Endpoint {
+    /** The bridge mode of Matterbridge */
     static bridgeMode = '';
-    static logLevel = "info";
+    /** The default log level of the new MatterbridgeEndpoints */
+    static logLevel = "info" /* LogLevel.INFO */;
+    /**
+     * Activates a special mode for this endpoint.
+     * - 'server': it creates the device server node and add the device as Matter device that needs to be paired individually.
+     *   In this case the bridge mode is not relevant. The device is autonomous. The main use case is a workaround for the Apple Home rvc issue.
+     *
+     * - 'matter': it adds the device directly to the bridge server node as Matter device. In this case the implementation must respect
+     *   the 9.2.3. Disambiguation rule (i.e. use taglist if needed cause the device doesn't have nodeLabel).
+     *   Furthermore the device will be a part of the bridge (i.e. will have the same name and will be in the same room).
+     *   See 9.12.2.2. Native Matter functionality in Bridge.
+     *
+     * @remarks
+     * Always use createDefaultBasicInformationClusterServer() to create the BasicInformation cluster server.
+     */
     mode = undefined;
+    /** The server node of the endpoint, if it is a single not bridged endpoint */
     serverNode;
+    /** The logger instance for the MatterbridgeEndpoint */
     log;
+    /** The plugin name this MatterbridgeEndpoint belongs to */
     plugin = undefined;
+    /** The configuration URL of the device, if available */
     configUrl = undefined;
     deviceName = undefined;
     serialNumber = undefined;
@@ -82,14 +129,28 @@ export class MatterbridgeEndpoint extends Endpoint {
     hardwareVersion = undefined;
     hardwareVersionString = undefined;
     productUrl = 'https://www.npmjs.com/package/matterbridge';
+    /** The name of the first device type of the endpoint (old api compatibility) */
     name = undefined;
+    /** The code of the first device type of the endpoint (old api compatibility) */
     deviceType = undefined;
+    /** The original id (with spaces and .) of the endpoint (old api compatibility) */
     uniqueStorageKey = undefined;
     tagList = undefined;
+    /** Maps the DeviceTypeDefinitions with their code */
     deviceTypes = new Map();
+    /** Command handler for the MatterbridgeEndpoint commands */
     commandHandler = new NamedHandler();
+    /**
+     * Represents a MatterbridgeEndpoint.
+     *
+     * @class MatterbridgeEndpoint
+     * @param {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The DeviceTypeDefinition(s) of the endpoint.
+     * @param {MatterbridgeEndpointOptions} [options] - The options for the device.
+     * @param {boolean} [debug] - Debug flag.
+     */
     constructor(definition, options = {}, debug = false) {
         let deviceTypeList = [];
+        // Get the first DeviceTypeDefinition
         let firstDefinition;
         if (Array.isArray(definition)) {
             firstDefinition = definition[0];
@@ -102,6 +163,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,
@@ -120,17 +182,20 @@ 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);
         }
         if (options.id && checkNotLatinCharacters(options.id)) {
             options.id = generateUniqueId(options.id);
         }
+        // Convert the options to an Endpoint.Options
         const optionsV8 = {
             id: options.uniqueStorageKey?.replace(/[ .]/g, ''),
             number: options.endpointId,
             descriptor: options.tagList ? { tagList: options.tagList, deviceTypeList } : { deviceTypeList },
         };
+        // Override the deprecated uniqueStorageKey && endpointId with id and number if provided
         if (options.id !== undefined) {
             optionsV8.id = options.id.replace(/[ .]/g, '');
         }
@@ -150,16 +215,40 @@ 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} mode: ${CYAN}${this.mode}${db} id: ${CYAN}${optionsV8.id}${db} number: ${CYAN}${optionsV8.number}${db} taglist: ${CYAN}${options.tagList ? debugStringify(options.tagList) : 'undefined'}${db}`);
+        // Add MatterbridgeServer
         this.behaviors.require(MatterbridgeServer, { log: this.log, commandHandler: this.commandHandler });
     }
+    /**
+     * 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] - 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)
@@ -167,6 +256,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])
@@ -175,82 +271,239 @@ 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, context: ActionContext) => void} listener - A callback function that will be called when the attribute value changes. When context.offline === true then the change is locally generated and not from the controller.
+     * @param {AnsiLogger} [log] - Optional logger for logging errors and information.
+     * @returns {Promise<boolean>} - A boolean indicating whether the subscription was successful.
+     *
+     * @remarks The listener function (cannot be async) will receive three parameters:
+     * - `newValue`: The new value of the attribute.
+     * - `oldValue`: The old value of the attribute.
+     * - `context`: The action context, which includes information about the action that triggered the change. When context.offline === true then the change is locally generated and not from the controller.
+     */
+    // 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} cluster - 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(cluster, event, payload, log) {
         return await triggerEvent(this, cluster, event, payload, log);
     }
+    /**
+     * 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 {CommandHandlerFunction} handler - The handler function to execute when the command is received.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The handler function will receive an object with the following properties:
+     * - `request`: The request object sent with the command.
+     * - `cluster`: The id of the cluster that received the command (i.e. "onOff").
+     * - `attributes`: The current attributes of the cluster that received the command (i.e. { onOff: true}).
+     * - `endpoint`: The MatterbridgeEndpoint instance that received the command.
+     */
     addCommandHandler(command, handler) {
         this.commandHandler.addHandler(command, handler);
         return this;
     }
+    /**
+     * Execute the command handler for the specified command. Used ONLY 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.
+     * @param {string} [cluster] - The optional cluster to pass to the handler function.
+     * @param {Record<string, boolean | number | bigint | string | object | null>} [attributes] - The optional attributes to pass to the handler function.
+     * @param {MatterbridgeEndpoint} [endpoint] - The optional MatterbridgeEndpoint instance to pass to the handler function
+     *
+     * @deprecated Used ONLY in Jest tests.
+     */
     async executeCommandHandler(command, request, cluster, attributes, endpoint) {
         await this.commandHandler.executeHandler(command, { request, cluster, attributes, endpoint });
     }
+    /**
+     * Invokes a behavior command on the specified cluster. Used ONLY in Jest tests.
+     *
+     * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to invoke the command on.
+     * @param {string} command - The command to invoke.
+     * @param {Record<string, boolean | number | bigint | string | object | null>} [params] - The optional parameters to pass to the command.
+     *
+     * @deprecated Used ONLY in Jest tests.
+     */
     async invokeBehaviorCommand(cluster, command, params) {
         await invokeBehaviorCommand(this, cluster, command, params);
     }
+    /**
+     * 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;
         for (const [clusterName, clusterAttributes] of Object.entries(this.state)) {
+            // Skip if the key / cluster name is a number, cause they are double indexed.
             if (!isNaN(Number(clusterName)))
                 continue;
             for (const [attributeName, attributeValue] of Object.entries(clusterAttributes)) {
+                // Skip if the behavior has no associated cluster (i.e. matterbridge server)
                 const clusterId = getClusterId(this, clusterName);
                 if (clusterId === undefined) {
+                    // this.log.debug(`***forEachAttribute: cluster ${clusterName} not found`);
                     continue;
                 }
+                // Skip if the attribute is not present in the ClusterBehavior.Type. Also skip if the attribute it is an internal state.
                 const attributeId = getAttributeId(this, clusterName, attributeName);
                 if (attributeId === undefined) {
+                    // this.log.debug(`***forEachAttribute: 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] - 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;
@@ -290,6 +543,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] - 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;
@@ -352,15 +622,39 @@ 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 {MatterbridgeEndpoint} device - The Matterbridge device to serialize.
+     *
+     * @returns {SerializedMatterbridgeEndpoint | undefined} The serialized Matterbridge device object.
+     */
     static serialize(device) {
         if (!device.serialNumber || !device.deviceName || !device.uniqueId)
             return;
@@ -383,9 +677,16 @@ 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.
+     *
+     * @param {SerializedMatterbridgeEndpoint} serializedDevice - The serialized Matterbridge device object.
+     * @returns {MatterbridgeEndpoint | undefined} The deserialized Matterbridge device.
+     */
     static deserialize(serializedDevice) {
         const device = new MatterbridgeEndpoint(serializedDevice.deviceTypes, { uniqueStorageKey: serializedDevice.endpointName, endpointId: serializedDevice.endpoint }, false);
         device.plugin = serializedDevice.pluginName;
@@ -401,55 +702,122 @@ 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 {PowerSource.WiredCurrentType} wiredCurrentType - The type of wired current (default: PowerSource.WiredCurrentType.Ac)
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * - order: The order of the power source is a persisted attribute that indicates the order in which the power sources are used.
+     * - description: The description of the power source is a fixed attribute that describes the power source type.
+     * - wiredCurrentType: The type of wired current is a fixed attribute that indicates the type of wired current used by the power source (AC or DC).
+     */
     createDefaultPowerSourceWiredClusterServer(wiredCurrentType = PowerSource.WiredCurrentType.Ac) {
         this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Wired), {
+            // Base attributes
             status: PowerSource.PowerSourceStatus.Active,
             order: 0,
             description: wiredCurrentType === PowerSource.WiredCurrentType.Ac ? 'AC Power' : 'DC Power',
             endpointList: [],
+            // Wired feature attributes
             wiredCurrentType,
         });
         return this;
     }
+    /**
+     * Creates a default power source replaceable battery cluster server.
+     *
+     * @param {number} batPercentRemaining - The remaining battery percentage (default: 100).
+     * @param {PowerSource.BatChargeLevel} batChargeLevel - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+     * @param {number} batVoltage - The battery voltage (default: 1500).
+     * @param {string} batReplacementDescription - The description of the battery replacement (default: 'Battery type').
+     * @param {number} batQuantity - The quantity of the battery (default: 1).
+     * @param {PowerSource.BatReplaceability} batReplaceability - The replaceability of the battery (default: PowerSource.BatReplaceability.Unspecified).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * - order: The order of the power source is a persisted attribute that indicates the order in which the power sources are used.
+     * - description: The description of the power source is a fixed attribute that describes the power source type.
+     * - batReplaceability: The replaceability of the battery is a fixed attribute that indicates whether the battery is user-replaceable or not.
+     * - batReplacementDescription: The description of the battery replacement is a fixed attribute that describes the battery type.
+     * - batQuantity: The quantity of the battery is a fixed attribute that indicates how many batteries are present in the device.
+     */
     createDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1, batReplaceability = PowerSource.BatReplaceability.UserReplaceable) {
         this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), {
+            // Base attributes
             status: PowerSource.PowerSourceStatus.Active,
             order: 0,
             description: 'Primary battery',
             endpointList: [],
+            // Battery feature attributes
             batVoltage,
             batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
             batChargeLevel,
             batReplacementNeeded: false,
             batReplaceability,
             activeBatFaults: undefined,
+            // Replaceable feature attributes
             batReplacementDescription,
             batQuantity,
         });
         return this;
     }
+    /**
+     * Creates a default power source rechargeable battery cluster server.
+     *
+     * @param {number} [batPercentRemaining] - The remaining battery percentage (default: 100).
+     * @param {PowerSource.BatChargeLevel} [batChargeLevel] - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+     * @param {number} [batVoltage] - The battery voltage in mV (default: 1500).
+     * @param {PowerSource.BatReplaceability} [batReplaceability] - The replaceability of the battery (default: PowerSource.BatReplaceability.Unspecified).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * - order: The order of the power source is a persisted attribute that indicates the order in which the power sources are used.
+     * - description: The description of the power source is a fixed attribute that describes the power source type.
+     * - batReplaceability: The replaceability of the battery is a fixed attribute that indicates whether the battery is user-replaceable or not.
+     */
     createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
         this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), {
+            // Base attributes
             status: PowerSource.PowerSourceStatus.Active,
             order: 0,
             description: 'Primary battery',
             endpointList: [],
+            // Battery feature attributes
             batVoltage,
             batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
-            batTimeRemaining: null,
+            batTimeRemaining: null, // Indicates the estimated time in seconds before the battery will no longer be able to provide power to the Node
             batChargeLevel,
             batReplacementNeeded: false,
             batReplaceability,
             batPresent: true,
             activeBatFaults: [],
+            // Rechargeable feature attributes
             batChargeState: PowerSource.BatChargeState.IsNotCharging,
             batFunctionalWhileCharging: true,
         });
         return this;
     }
+    /**
+     * Setup the default Basic Information Cluster Server attributes for the server node.
+     *
+     * @param {string} deviceName - The name of the device.
+     * @param {string} serialNumber - The serial number of the device.
+     * @param {number} [vendorId] - The vendor ID of the device.  Default is 0xfff1 (Matter Test VendorId).
+     * @param {string} [vendorName] - The name of the vendor. Default is 'Matterbridge'.
+     * @param {number} [productId] - The product ID of the device.  Default is 0x8000 (Matter Test ProductId).
+     * @param {string} [productName] - The name of the product. Default is 'Matterbridge device'.
+     * @param {number} [softwareVersion] - The software version of the device. Default is 1.
+     * @param {string} [softwareVersionString] - The software version string of the device. Default is '1.0.0'.
+     * @param {number} [hardwareVersion] - The hardware version of the device. Default is 1.
+     * @param {string} [hardwareVersionString] - The hardware version string of the device. Default is '1.0.0'.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultBasicInformationClusterServer(deviceName, serialNumber, vendorId = 0xfff1, vendorName = 'Matterbridge', productId = 0x8000, productName = 'Matterbridge device', softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
         this.log.logName = deviceName;
         this.deviceName = deviceName;
@@ -473,6 +841,22 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         return this;
     }
+    /**
+     * Creates a default BridgedDeviceBasicInformationClusterServer for the aggregator endpoints.
+     *
+     * @param {string} deviceName - The name of the device.
+     * @param {string} serialNumber - The serial number of the device.
+     * @param {number} [vendorId] - The vendor ID of the device. Default is 0xfff1 (Matter Test VendorId).
+     * @param {string} [vendorName] - The name of the vendor. Default is 'Matterbridge'.
+     * @param {string} [productName] - The name of the product. Default is 'Matterbridge device'.
+     * @param {number} [softwareVersion] - The software version of the device. Default is 1.
+     * @param {string} [softwareVersionString] - The software version string of the device. Default is '1.0.0'.
+     * @param {number} [hardwareVersion] - The hardware version of the device. Default is 1.
+     * @param {string} [hardwareVersionString] - The hardware version string of the device. Default is '1.0.0'.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks The bridgedNode device type must be added to the deviceTypeList of the Descriptor cluster.
+     */
     createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber, vendorId = 0xfff1, vendorName = 'Matterbridge', productName = 'Matterbridge device', softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
         this.log.logName = deviceName;
         this.deviceName = deviceName;
@@ -505,6 +889,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default identify cluster server with the specified identify time and type.
+     *
+     * @param {number} [identifyTime] - The time to identify the server. Defaults to 0.
+     * @param {Identify.IdentifyType} [identifyType] - 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,
@@ -512,14 +903,36 @@ 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.
+     *
+     * @remarks The scenes management cluster server is still provisional and so not yet implemented.
+     */
     createDefaultScenesClusterServer() {
         this.behaviors.require(ScenesManagementServer);
         return this;
     }
+    /**
+     * Creates a default OnOff cluster server for light devices with feature Lighting.
+     *
+     * @param {boolean} [onOff] - The initial state of the OnOff cluster.
+     * @param {boolean} [globalSceneControl] - The global scene control state.
+     * @param {number} [onTime] - The on time value.
+     * @param {number} [offWaitTime] - The off wait time value.
+     * @param {OnOff.StartUpOnOff | null} [startUpOnOff] - 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,
@@ -530,24 +943,52 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates an OnOff cluster server without features.
+     *
+     * @param {boolean} [onOff] - 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 with feature DeadFrontBehavior.
+     *
+     * @param {boolean} [onOff] - 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 with feature OffOnly.
+     *
+     * @param {boolean} [onOff] - 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 with feature OnOff and Lighting.
+     *
+     * @param {number} [currentLevel] - The current level (default: 254).
+     * @param {number} [minLevel] - The minimum level (default: 1).
+     * @param {number} [maxLevel] - The maximum level (default: 254).
+     * @param {number | null} [onLevel] - The on level (default: null).
+     * @param {number | null} [startUpCurrentLevel] - 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,
@@ -563,6 +1004,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a level control cluster server without features.
+     *
+     * @param {number} [currentLevel] - The current level (default: 254).
+     * @param {number | null} [onLevel] - The on level (default: null).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createLevelControlClusterServer(currentLevel = 254, onLevel = null) {
         this.behaviors.require(MatterbridgeLevelControlServer, {
             currentLevel,
@@ -574,6 +1022,25 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default color control cluster server with features Xy, HueSaturation and ColorTemperature.
+     *
+     * @param {number} currentX - The current X value (range 0-65279).
+     * @param {number} currentY - The current Y value (range 0-65279).
+     * @param {number} currentHue - The current hue value (range: 0-254).
+     * @param {number} currentSaturation - The current saturation value (range: 0-254).
+     * @param {number} colorTemperatureMireds - The color temperature in mireds (default range 147-500).
+     * @param {number} colorTempPhysicalMinMireds - The physical minimum color temperature in mireds (default range 147).
+     * @param {number} colorTempPhysicalMaxMireds - The physical maximum color temperature in mireds (default range 500).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks colorMode and enhancedColorMode persist across restarts.
+     * @remarks currentHue and currentSaturation persist across restarts.
+     * @remarks currentX and currentY persist across restarts.
+     * @remarks colorTemperatureMireds persists across restarts.
+     * @remarks startUpColorTemperatureMireds persists across restarts.
+     * @remarks coupleColorTempToLevelMinMireds persists across restarts.
+     */
     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,
@@ -596,6 +1063,25 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a Xy color control cluster server with feature Xy and ColorTemperature.
+     *
+     * @param {number} currentX - The current X value (range 0-65279).
+     * @param {number} currentY - The current Y value (range 0-65279).
+     * @param {number} colorTemperatureMireds - The color temperature in mireds (default range 147-500).
+     * @param {number} colorTempPhysicalMinMireds - The physical minimum color temperature in mireds (default range 147).
+     * @param {number} colorTempPhysicalMaxMireds - The physical maximum color temperature in mireds (default range 500).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * From zigbee to matter = Math.max(Math.min(Math.round(x * 65536), 65279), 0)
+     *
+     * @remarks colorMode and enhancedColorMode persist across restarts.
+     * @remarks currentX and currentY persist across restarts.
+     * @remarks colorTemperatureMireds persists across restarts.
+     * @remarks startUpColorTemperatureMireds persists across restarts.
+     * @remarks coupleColorTempToLevelMinMireds persists across restarts.
+     */
     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,
@@ -616,6 +1102,22 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default hue and saturation control cluster server with feature HueSaturation and ColorTemperature.
+     *
+     * @param {number} currentHue - The current hue value (range: 0-254).
+     * @param {number} currentSaturation - The current saturation value (range: 0-254).
+     * @param {number} colorTemperatureMireds - The color temperature in mireds (default range 147-500).
+     * @param {number} colorTempPhysicalMinMireds - The physical minimum color temperature in mireds (default range 147).
+     * @param {number} colorTempPhysicalMaxMireds - The physical maximum color temperature in mireds (default range 500).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks colorMode and enhancedColorMode persist across restarts.
+     * @remarks currentHue and currentSaturation persist across restarts.
+     * @remarks colorTemperatureMireds persists across restarts.
+     * @remarks startUpColorTemperatureMireds persists across restarts.
+     * @remarks coupleColorTempToLevelMinMireds persists across restarts.
+     */
     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,
@@ -636,6 +1138,20 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a color temperature color control cluster server with feature ColorTemperature.
+     * This cluster server is used for devices that only support color temperature control.
+     *
+     * @param {number} colorTemperatureMireds - The color temperature in mireds (default range 147-500).
+     * @param {number} colorTempPhysicalMinMireds - The physical minimum color temperature in mireds (default range 147).
+     * @param {number} colorTempPhysicalMaxMireds - The physical maximum color temperature in mireds (default range 500).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks colorMode and enhancedColorMode persist across restarts.
+     * @remarks colorTemperatureMireds persists across restarts.
+     * @remarks startUpColorTemperatureMireds persists across restarts.
+     * @remarks coupleColorTempToLevelMinMireds persists across restarts.
+     */
     createCtColorControlClusterServer(colorTemperatureMireds = 250, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
@@ -654,15 +1170,34 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Configures the color control mode for the device.
+     *
+     * @param {ColorControl.ColorMode} colorMode - The color mode to set.
+     *
+     * @remarks colorMode and enhancedColorMode persist across restarts.
+     */
     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 with feature Lift and PositionAwareLift.
+     *
+     * @param {number} positionPercent100ths - The position percentage in 100ths (0-10000). Defaults to 0. Matter uses 10000 = fully closed 0 = fully opened.
+     * @param {WindowCovering.WindowCoveringType} type - The type of window covering (default: WindowCovering.WindowCoveringType.Rollershade). Must support feature Lift.
+     * @param {WindowCovering.EndProductType} endProductType - The end product type (default: WindowCovering.EndProductType.RollerShade). Must support feature Lift.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks mode attributes is writable and persists across restarts.
+     * currentPositionLiftPercent100ths persists across restarts.
+     * configStatus attributes persists across restarts.
+     */
     createDefaultWindowCoveringClusterServer(positionPercent100ths, type = WindowCovering.WindowCoveringType.Rollershade, endProductType = WindowCovering.EndProductType.RollerShade) {
         this.behaviors.require(MatterbridgeLiftWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift), {
-            type,
+            type, // Must support feature Lift
             numberOfActuationsLift: 0,
             configStatus: {
                 operational: true,
@@ -670,20 +1205,33 @@ export class MatterbridgeEndpoint extends Endpoint {
                 liftMovementReversed: false,
                 liftPositionAware: true,
                 tiltPositionAware: false,
-                liftEncoderControlled: false,
-                tiltEncoderControlled: false,
+                liftEncoderControlled: false, // 0 = Timer Controlled 1 = Encoder Controlled
+                tiltEncoderControlled: false, // 0 = Timer Controlled 1 = Encoder Controlled
             },
             operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
-            endProductType,
+            endProductType, // Must support feature Lift
             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;
     }
+    /**
+     * Creates a default window covering cluster server with features Lift, PositionAwareLift, Tilt, PositionAwareTilt.
+     *
+     * @param {number} positionLiftPercent100ths - The lift position percentage in 100ths (0-10000). Defaults to 0. Matter uses 10000 = fully closed 0 = fully opened.
+     * @param {number} positionTiltPercent100ths - The tilt position percentage in 100ths (0-10000). Defaults to 0. Matter uses 10000 = fully closed 0 = fully opened.
+     * @param {WindowCovering.WindowCoveringType} type - The type of window covering (default: WindowCovering.WindowCoveringType.TiltBlindLift). Must support features Lift and Tilt.
+     * @param {WindowCovering.EndProductType} endProductType - The end product type (default: WindowCovering.EndProductType.InteriorBlind). Must support features Lift and Tilt.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks mode attributes is writable and persists across restarts.
+     * currentPositionTiltPercent100ths persists across restarts.
+     * configStatus attributes persists across restarts.
+     */
     createDefaultLiftTiltWindowCoveringClusterServer(positionLiftPercent100ths, positionTiltPercent100ths, type = WindowCovering.WindowCoveringType.TiltBlindLift, endProductType = WindowCovering.EndProductType.InteriorBlind) {
         this.behaviors.require(MatterbridgeLiftTiltWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt), {
-            type,
+            type, // Must support features Lift and Tilt
             numberOfActuationsLift: 0,
             numberOfActuationsTilt: 0,
             configStatus: {
@@ -692,19 +1240,23 @@ export class MatterbridgeEndpoint extends Endpoint {
                 liftMovementReversed: false,
                 liftPositionAware: true,
                 tiltPositionAware: true,
-                liftEncoderControlled: false,
-                tiltEncoderControlled: false,
+                liftEncoderControlled: false, // 0 = Timer Controlled 1 = Encoder Controlled
+                tiltEncoderControlled: false, // 0 = Timer Controlled 1 = Encoder Controlled
             },
             operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
-            endProductType,
+            endProductType, // Must support features Lift and Tilt
             mode: { motorDirectionReversed: false, calibrationMode: false, maintenanceMode: false, ledFeedback: false },
-            targetPositionLiftPercent100ths: positionLiftPercent100ths ?? 0,
-            currentPositionLiftPercent100ths: positionLiftPercent100ths ?? 0,
-            targetPositionTiltPercent100ths: positionTiltPercent100ths ?? 0,
-            currentPositionTiltPercent100ths: positionTiltPercent100ths ?? 0,
+            targetPositionLiftPercent100ths: positionLiftPercent100ths ?? 0, // 0 Fully open 10000 fully closed
+            currentPositionLiftPercent100ths: positionLiftPercent100ths ?? 0, // 0 Fully open 10000 fully closed
+            targetPositionTiltPercent100ths: positionTiltPercent100ths ?? 0, // 0 Fully open 10000 fully closed
+            currentPositionTiltPercent100ths: positionTiltPercent100ths ?? 0, // 0 Fully open 10000 fully closed
         });
         return this;
     }
+    /**
+     * Sets the window covering lift 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)) {
@@ -724,6 +1276,13 @@ export class MatterbridgeEndpoint extends Endpoint {
             this.log.debug(`Set WindowCovering currentPositionTiltPercent100ths and targetPositionTiltPercent100ths to ${position} and operationalStatus to Stopped.`);
         }
     }
+    /**
+     * Sets the lift current and target position and the 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);
@@ -734,6 +1293,11 @@ 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,
@@ -742,6 +1306,11 @@ export class MatterbridgeEndpoint extends Endpoint {
         }, this.log);
         this.log.debug(`Set WindowCovering operationalStatus: ${status}`);
     }
+    /**
+     * Retrieves the status of the window covering.
+     *
+     * @returns {WindowCovering.MovementStatus | undefined} The movement status of the window covering, or undefined if not available.
+     */
     getWindowCoveringStatus() {
         const status = this.getAttribute(WindowCovering.Cluster.id, 'operationalStatus', this.log);
         if (isValidObject(status, 3) && 'global' in status && typeof status.global === 'number') {
@@ -749,6 +1318,12 @@ export class MatterbridgeEndpoint extends Endpoint {
             return status.global;
         }
     }
+    /**
+     * Sets the lift target and current position of the window covering.
+     *
+     * @param {number} liftPosition - The position to set, specified as a number.
+     * @param {number} [tiltPosition] - The tilt position to set, specified as a number.
+     */
     async setWindowCoveringTargetAndCurrentPosition(liftPosition, tiltPosition) {
         await this.setAttribute(WindowCovering.Cluster.id, 'currentPositionLiftPercent100ths', liftPosition, this.log);
         await this.setAttribute(WindowCovering.Cluster.id, 'targetPositionLiftPercent100ths', liftPosition, this.log);
@@ -759,31 +1334,57 @@ export class MatterbridgeEndpoint extends Endpoint {
             this.log.debug(`Set WindowCovering currentPositionTiltPercent100ths: ${tiltPosition} and targetPositionTiltPercent100ths: ${tiltPosition}.`);
         }
     }
+    /**
+     * Creates a default thermostat cluster server with features Heating, Cooling and AutoMode.
+     *
+     * @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} [occupiedCoolingSetpoint] - The occupied cooling setpoint value in degrees Celsius. Defaults to 25°.
+     * @param {number} [minSetpointDeadBand] - The minimum setpoint dead band value. Defaults to 1°.
+     * @param {number} [minHeatSetpointLimit] - The minimum heat setpoint limit value. Defaults to 0°.
+     * @param {number} [maxHeatSetpointLimit] - The maximum heat setpoint limit value. Defaults to 50°.
+     * @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.
+     */
     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 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,
@@ -792,11 +1393,21 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default cooling thermostat cluster server with 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,
@@ -805,6 +1416,16 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default thermostat user interface configuration cluster server.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     * @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,
@@ -813,95 +1434,273 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default fan control cluster server with features Auto, and Step and mode Off Low Med High Auto.
+     *
+     * @param {FanControl.FanMode} [fanMode] - The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @param {FanControl.FanModeSequence} [fanModeSequence] - The fan mode sequence to set. Defaults to `FanControl.FanModeSequence.OffLowMedHighAuto`.
+     * @param {number} [percentSetting] - The initial percent setting. Defaults to 0.
+     * @param {number} [percentCurrent] - The initial percent current. Defaults to 0.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * - fanmode is writable and persists across reboots.
+     * - fanModeSequence is fixed.
+     * - percentSetting is writable.
+     */
     createDefaultFanControlClusterServer(fanMode = FanControl.FanMode.Off, fanModeSequence = FanControl.FanModeSequence.OffLowMedHighAuto, percentSetting = 0, percentCurrent = 0) {
         this.behaviors.require(MatterbridgeFanControlServer.with(FanControl.Feature.Auto, FanControl.Feature.Step), {
-            fanMode,
-            fanModeSequence,
-            percentSetting,
+            // Base fan control attributes
+            fanMode, // Writable and persistent attribute
+            fanModeSequence, // Fixed attribute
+            percentSetting, // Writable attribute
             percentCurrent,
         });
         return this;
     }
+    /**
+     * Creates an On Off fan control cluster server without features and mode Off High.
+     *
+     * @param {FanControl.FanMode} [fanMode] - The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * fanmode is writable and persists across reboots.
+     * fanModeSequence is fixed.
+     * percentSetting is writable.
+     */
     createOnOffFanControlClusterServer(fanMode = FanControl.FanMode.Off) {
         this.behaviors.require(FanControlServer, {
-            fanMode,
-            fanModeSequence: FanControl.FanModeSequence.OffHigh,
-            percentSetting: 0,
+            // Base fan control attributes
+            fanMode, // Writable and persistent attribute
+            fanModeSequence: FanControl.FanModeSequence.OffHigh, // Fixed attribute
+            percentSetting: 0, // Writable attribute
             percentCurrent: 0,
         });
         return this;
     }
+    /**
+     * Creates a base fan control cluster server without features and mode Off Low Med High.
+     *
+     * @param {FanControl.FanMode} [fanMode] - The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @param {FanControl.FanModeSequence} [fanModeSequence] - The fan mode sequence to set. Defaults to `FanControl.FanModeSequence.OffLowMedHigh`.
+     * @param {number} [percentSetting] - The initial percent setting. Defaults to 0.
+     * @param {number} [percentCurrent] - The initial percent current. Defaults to 0.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * fanmode is writable and persists across reboots.
+     * fanModeSequence is fixed.
+     * percentSetting is writable.
+     */
     createBaseFanControlClusterServer(fanMode = FanControl.FanMode.Off, fanModeSequence = FanControl.FanModeSequence.OffLowMedHigh, percentSetting = 0, percentCurrent = 0) {
         this.behaviors.require(FanControlServer, {
-            fanMode,
-            fanModeSequence,
-            percentSetting,
+            // Base fan control attributes
+            fanMode, // Writable and persistent attribute
+            fanModeSequence, // Fixed attribute
+            percentSetting, // Writable attribute
             percentCurrent,
         });
         return this;
     }
+    /**
+     * Creates a fan control cluster server with features MultiSpeed, Auto, and Step and mode Off Low Med High Auto.
+     *
+     * @param {FanControl.FanMode} [fanMode] - The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @param {FanControl.FanModeSequence} [fanModeSequence] - The fan mode sequence to set. Defaults to `FanControl.FanModeSequence.OffLowMedHighAuto`.
+     * @param {number} [percentSetting] - The initial percent setting. Defaults to 0.
+     * @param {number} [percentCurrent] - The initial percent current. Defaults to 0.
+     * @param {number} [speedMax] - The maximum speed setting. Defaults to 10.
+     * @param {number} [speedSetting] - The initial speed setting. Defaults to 0.
+     * @param {number} [speedCurrent] - The initial speed current. Defaults to 0.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * - fanmode is writable and persists across reboots.
+     * - fanModeSequence is fixed.
+     * - percentSetting is writable.
+     * - speedMax is fixed.
+     * - speedSetting is writable.
+     */
     createMultiSpeedFanControlClusterServer(fanMode = FanControl.FanMode.Off, fanModeSequence = FanControl.FanModeSequence.OffLowMedHighAuto, percentSetting = 0, percentCurrent = 0, speedMax = 10, speedSetting = 0, speedCurrent = 0) {
         this.behaviors.require(MatterbridgeFanControlServer.with(FanControl.Feature.MultiSpeed, FanControl.Feature.Auto, FanControl.Feature.Step), {
-            fanMode,
-            fanModeSequence,
-            percentSetting,
+            // Base fan control attributes
+            fanMode, // Writable and persistent attribute
+            fanModeSequence, // Fixed attribute
+            percentSetting, // Writable attribute
             percentCurrent,
-            speedMax,
-            speedSetting,
+            // MultiSpeed feature
+            speedMax, // Fixed attribute
+            speedSetting, // Writable attribute
             speedCurrent,
         });
         return this;
     }
+    /**
+     * Creates a fan control cluster server with features MultiSpeed, Auto, Step, Rock, Wind and AirflowDirection and mode Off Low Med High Auto.
+     *
+     * @param {FanControl.FanMode} [fanMode] - The fan mode to set. Defaults to `FanControl.FanMode.Off`.
+     * @param {FanControl.FanModeSequence} [fanModeSequence] - The fan mode sequence to set. Defaults to `FanControl.FanModeSequence.OffLowMedHighAuto`.
+     * @param {number} [percentSetting] - The initial percent setting. Defaults to 0.
+     * @param {number} [percentCurrent] - The initial percent current. Defaults to 0.
+     * @param {number} [speedMax] - The maximum speed setting. Defaults to 10.
+     * @param {number} [speedSetting] - The initial speed setting. Defaults to 0.
+     * @param {number} [speedCurrent] - The initial speed current. Defaults to 0.
+     * @param {object} [rockSupport] - The rock support configuration.
+     * @param {boolean} rockSupport.rockLeftRight - Indicates support for rocking left to right. Defaults to true.
+     * @param {boolean} rockSupport.rockUpDown - Indicates support for rocking up and down. Defaults to true.
+     * @param {boolean} rockSupport.rockRound - Indicates support for round rocking. Defaults to true.
+     * @param {object} [rockSetting] - The rock setting configuration.
+     * @param {boolean} rockSetting.rockLeftRight - Indicates the current setting for rocking left to right. Defaults to true.
+     * @param {boolean} rockSetting.rockUpDown - Indicates the current setting for rocking up and down. Defaults to true.
+     * @param {boolean} rockSetting.rockRound - Indicates the current setting for round rocking. Defaults to true.
+     * @param {object} [windSupport] - The wind support configuration.
+     * @param {boolean} windSupport.sleepWind - Indicates support for sleep wind. Defaults to true.
+     * @param {boolean} windSupport.naturalWind - Indicates support for natural wind. Defaults to true.
+     * @param {object} [windSetting] - The wind setting configuration.
+     * @param {boolean} windSetting.sleepWind - Indicates the current setting for sleep wind. Defaults to false.
+     * @param {boolean} windSetting.naturalWind - Indicates the current setting for natural wind. Defaults to true.
+     * @param {FanControl.AirflowDirection} [airflowDirection] - The airflow direction. Defaults to `FanControl.AirflowDirection.Forward`.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * - fanmode is writable and persists across reboots.
+     * - fanModeSequence is fixed.
+     * - percentSetting is writable.
+     * - speedMax is fixed.
+     * - speedSetting is writable.
+     * - rockSupport is fixed.
+     * - rockSetting is writable.
+     * - windSupport is fixed.
+     * - windSetting is writable.
+     * - airflowDirection is writable.
+     */
     createCompleteFanControlClusterServer(fanMode = FanControl.FanMode.Off, fanModeSequence = FanControl.FanModeSequence.OffLowMedHighAuto, percentSetting = 0, percentCurrent = 0, speedMax = 10, speedSetting = 0, speedCurrent = 0, rockSupport = { rockLeftRight: true, rockUpDown: true, rockRound: true }, rockSetting = { rockLeftRight: true, rockUpDown: false, rockRound: false }, windSupport = { sleepWind: true, naturalWind: true }, windSetting = { sleepWind: false, naturalWind: true }, airflowDirection = FanControl.AirflowDirection.Forward) {
         this.behaviors.require(MatterbridgeFanControlServer.with(FanControl.Feature.MultiSpeed, FanControl.Feature.Auto, FanControl.Feature.Step, FanControl.Feature.Rocking, FanControl.Feature.Wind, FanControl.Feature.AirflowDirection), {
-            fanMode,
-            fanModeSequence,
-            percentSetting,
+            // Base fan control attributes
+            fanMode, // Writable and persistent attribute
+            fanModeSequence, // Fixed attribute
+            percentSetting, // Writable attribute
             percentCurrent,
-            speedMax,
-            speedSetting,
+            // MultiSpeed feature
+            speedMax, // Fixed attribute
+            speedSetting, // Writable attribute
             speedCurrent,
-            rockSupport,
-            rockSetting,
-            windSupport,
-            windSetting,
-            airflowDirection,
+            // Rocking feature
+            rockSupport, // Fixed attribute
+            rockSetting, // Writable attribute
+            // Wind feature
+            windSupport, // Fixed attribute
+            windSetting, // Writable attribute
+            // AirflowDirection feature
+            airflowDirection, // Writable attribute
         });
         return this;
     }
+    /**
+     * Creates a default HEPA Filter Monitoring Cluster Server with features Condition and ReplacementProductList.
+     * It supports ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.Warning, and ResourceMonitoring.Feature.ReplacementProductList.
+     *
+     * @param {number} condition - The initial condition value (range 0-100). Default is 100.
+     * @param {ResourceMonitoring.ChangeIndication} changeIndication - The initial change indication. Default is ResourceMonitoring.ChangeIndication.Ok.
+     * @param {boolean | undefined} inPlaceIndicator - The in-place indicator. Default is true.
+     * @param {number | undefined} lastChangedTime - The last changed time (EpochS). Default is null.
+     * @param {ResourceMonitoring.ReplacementProduct[]} replacementProductList - The list of replacement products. Default is an empty array. It is a fixed attribute.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The HEPA Filter Monitoring Cluster Server is used to monitor the status of HEPA filters.
+     * It provides information about the condition of the filter, whether it is in place, and the last time it was changed.
+     * The change indication can be used to indicate if the filter needs to be replaced or serviced.
+     * The replacement product list can be used to provide a list of replacement products for the filter.
+     * The condition attribute is fixed at 100, indicating a healthy filter.
+     * The degradation direction is fixed at ResourceMonitoring.DegradationDirection.Down, indicating that a lower value indicates a worse condition.
+     * The replacement product list is initialized as an empty array.
+     */
     createDefaultHepaFilterMonitoringClusterServer(condition = 100, changeIndication = ResourceMonitoring.ChangeIndication.Ok, inPlaceIndicator = true, lastChangedTime = null, replacementProductList = []) {
         this.behaviors.require(MatterbridgeHepaFilterMonitoringServer.with(ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.Warning, ResourceMonitoring.Feature.ReplacementProductList), {
+            // Feature.Condition
             condition,
-            degradationDirection: ResourceMonitoring.DegradationDirection.Down,
-            replacementProductList,
+            degradationDirection: ResourceMonitoring.DegradationDirection.Down, // Fixed attribute
+            // Feature.ReplacementProductList
+            replacementProductList, // Fixed attribute
+            // Base attributes
             changeIndication,
             inPlaceIndicator,
-            lastChangedTime,
+            lastChangedTime, // Writable and persistent across restarts
         });
         return this;
     }
+    /**
+     * Creates a default Activated Carbon Filter Monitoring Cluster Server with features Condition and ReplacementProductList.
+     * It supports ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.Warning, and ResourceMonitoring.Feature.ReplacementProductList.
+     *
+     * @param {number} condition - The initial condition value (range 0-100). Default is 100.
+     * @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.
+     * @param {ResourceMonitoring.ReplacementProduct[]} replacementProductList - The list of replacement products. Default is an empty array. It is a fixed attribute.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The Activated Carbon Filter Monitoring Cluster Server is used to monitor the status of activated carbon filters.
+     * It provides information about the condition of the filter, whether it is in place, and the last time it was changed.
+     * The change indication can be used to indicate if the filter needs to be replaced or serviced.
+     * The replacement product list can be used to provide a list of replacement products for the filter.
+     * The condition attribute is fixed at 100, indicating a healthy filter.
+     * The degradation direction is fixed at ResourceMonitoring.DegradationDirection.Down, indicating that a lower value indicates a worse condition.
+     * The replacement product list is initialized as an empty array.
+     */
     createDefaultActivatedCarbonFilterMonitoringClusterServer(condition = 100, changeIndication = ResourceMonitoring.ChangeIndication.Ok, inPlaceIndicator = true, lastChangedTime = null, replacementProductList = []) {
         this.behaviors.require(MatterbridgeActivatedCarbonFilterMonitoringServer.with(ResourceMonitoring.Feature.Condition, ResourceMonitoring.Feature.Warning, ResourceMonitoring.Feature.ReplacementProductList), {
+            // Feature.Condition
             condition,
             degradationDirection: ResourceMonitoring.DegradationDirection.Down,
-            replacementProductList,
+            // Feature.ReplacementProductList
+            replacementProductList, // Fixed attribute
+            // Base attributes
             changeIndication,
             inPlaceIndicator,
-            lastChangedTime,
+            lastChangedTime, // Writable and persistent across restarts
         });
         return this;
     }
+    /**
+     * Creates a default door lock cluster server.
+     *
+     * @param {DoorLock.LockState} [lockState] - The initial state of the lock (default: Locked).
+     * @param {DoorLock.LockType} [lockType] - 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] - The current mode (default: 0).
+     * @param {number} [startUpMode] - 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,
@@ -912,21 +1711,35 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates the default Valve Configuration And Control cluster server with features Level.
+     *
+     * @param {ValveConfigurationAndControl.ValveState} [valveState] - The valve state to set. Defaults to `ValveConfigurationAndControl.ValveState.Closed`.
+     * @param {number} [valveLevel] - 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,
             targetState: valveState,
             openDuration: null,
-            defaultOpenDuration: null,
+            defaultOpenDuration: null, // Writable and persistent across restarts
             remainingDuration: null,
             valveFault: { generalFault: false, blocked: false, leaking: false, notConnected: false, shortCircuit: false, currentExceeded: false },
+            // Feature.Level
             currentLevel: valveLevel,
             targetLevel: valveLevel,
-            defaultOpenLevel: 100,
-            levelStep: 1,
+            defaultOpenLevel: 100, // Writable and persistent across restarts
+            levelStep: 1, // Fixed
         });
         return this;
     }
+    /**
+     * Creates the default PumpConfigurationAndControl cluster server with features ConstantSpeed.
+     *
+     * @param {PumpConfigurationAndControl.OperationMode} [pumpMode] - 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,
@@ -941,6 +1754,13 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates the default SmokeCOAlarm Cluster Server with features SmokeAlarm and CoAlarm.
+     *
+     * @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 },
@@ -956,6 +1776,12 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a smoke only SmokeCOAlarm Cluster Server with features SmokeAlarm.
+     *
+     * @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 },
@@ -970,6 +1796,12 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a co only SmokeCOAlarm Cluster Server with features CoAlarm.
+     *
+     * @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 },
@@ -984,6 +1816,15 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default momentary switch cluster server with features MomentarySwitch, MomentarySwitchRelease, MomentarySwitchLongPress and MomentarySwitchMultiPress
+     * and events initialPress, longPress, shortRelease, longRelease, multiPressOngoing, multiPressComplete.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * This method adds a cluster server with default momentary switch features and configuration suitable for (AppleHome) Single Double Long automations.
+     */
     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 },
@@ -994,6 +1835,15 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default momentary switch cluster server with feature MomentarySwitch and event initialPress.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * This method adds a cluster server with default momentary switch features and configuration suitable for a Single press automations.
+     * It is supported by the Home app.
+     */
     createDefaultMomentarySwitchClusterServer() {
         this.behaviors.require(MatterbridgeSwitchServer.with(Switch.Feature.MomentarySwitch).enable({
             events: { initialPress: true },
@@ -1003,6 +1853,14 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default latching switch cluster server with features LatchingSwitch.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * This method adds a cluster server with default latching switch features and configuration suitable for a latching switch with 2 positions.
+     */
     createDefaultLatchingSwitchClusterServer() {
         this.behaviors.require(SwitchServer.with(Switch.Feature.LatchingSwitch).enable({
             events: { switchLatched: true },
@@ -1012,6 +1870,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 {AnsiLogger} log - Optional logger to log the event.
+     * @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}`);
@@ -1073,10 +1938,37 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         return true;
     }
+    /**
+     * Creates a default OperationalState Cluster Server.
+     *
+     * @param {OperationalState.OperationalStateEnum} operationalState - The initial operational state id.
+     *
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * This method adds a cluster server with a default operational state configuration:
+     * - { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+     * - { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+     * - { operationalStateId: OperationalState.OperationalStateEnum.Paused, operationalStateLabel: 'Paused' },
+     * - { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+     */
     createDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
         this.behaviors.require(MatterbridgeOperationalStateServer, getDefaultOperationalStateClusterServer(operationalState));
         return this;
     }
+    /**
+     * Creates a default boolean state cluster server.
+     * The stateChange event is enabled.
+     *
+     * @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 },
@@ -1085,6 +1977,22 @@ 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.
+     *
+     * Features:
+     * - Visual
+     * - Audible
+     * - SensitivityLevel
+     *
+     * @remarks Supports the enableDisableAlarm command.
+     *
+     * @param {boolean} [sensorFault] - Optional boolean value indicating the sensor fault state. Defaults to `false` if not provided.
+     * @param {number} [currentSensitivityLevel] - The current sensitivity level. Defaults to `0` if not provided.
+     * @param {number} [supportedSensitivityLevels] - The number of supported sensitivity levels. Defaults to `2` if not provided (min 2, max 10).
+     * @param {number} [defaultSensitivityLevel] - 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 },
@@ -1099,18 +2007,51 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default Device Energy Management Cluster Server with feature PowerForecastReporting and with the specified ESA type, ESA canGenerate, ESA state, and power limits.
+     *
+     * @param {DeviceEnergyManagement.EsaType} [esaType] - The ESA type. Defaults to `DeviceEnergyManagement.EsaType.Other`.
+     * @param {boolean} [esaCanGenerate] - Indicates if the ESA can generate energy. Defaults to `false`.
+     * @param {DeviceEnergyManagement.EsaState} [esaState] - The ESA state. Defaults to `DeviceEnergyManagement.EsaState.Online`.
+     * @param {number} [absMinPower] - Indicate the minimum electrical power in mw that the ESA can consume when switched on. Defaults to `0` if not provided.
+     * @param {number} [absMaxPower] - Indicate the maximum electrical power in mw that the ESA can consume when switched on. Defaults to `0` if not provided.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * - The forecast attribute is set to null, indicating that there is no forecast currently available.
+     * - The ESA type and canGenerate attributes are fixed and cannot be changed after creation.
+     * - The ESA state is set to Online by default.
+     * - The absolute minimum and maximum power attributes are set to 0 by default.
+     * - For example, a battery storage inverter that can charge its battery at a maximum power of 2000W and can
+     * discharge the battery at a maximum power of 3000W, would have a absMinPower: -3000W, absMaxPower: 2000W.
+     */
     createDefaultDeviceEnergyManagementClusterServer(esaType = DeviceEnergyManagement.EsaType.Other, esaCanGenerate = false, esaState = DeviceEnergyManagement.EsaState.Online, absMinPower = 0, absMaxPower = 0) {
         this.behaviors.require(MatterbridgeDeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment), {
-            forecast: null,
-            powerAdjustmentCapability: null,
-            esaType,
-            esaCanGenerate,
+            forecast: null, // A null value indicates that there is no forecast currently available
+            powerAdjustmentCapability: null, // A null value indicates that no power adjustment is currently possible, and nor is any adjustment currently active
+            esaType, // Fixed attribute
+            esaCanGenerate, // Fixed attribute
             esaState,
             absMinPower,
             absMaxPower,
         });
         return this;
     }
+    /**
+     * Creates a default EnergyManagementMode Cluster Server.
+     *
+     * @param {number} [currentMode] - The current mode of the EnergyManagementMode cluster. Defaults to mode 1 (DeviceEnergyManagementMode.ModeTag.NoOptimization).
+     * @param {EnergyManagementMode.ModeOption[]} [supportedModes] - The supported modes for the DeviceEnergyManagementMode cluster. The attribute is fixed and defaults to a predefined set of cluster modes.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * A few examples of Device Energy Management modes and their mode tags are provided below.
+     *  - For the "No Energy Management (Forecast reporting only)" mode, tags: 0x4000 (NoOptimization).
+     *  - For the "Device Energy Management" mode, tags: 0x4001 (DeviceOptimization).
+     *  - For the "Home Energy Management" mode, tags: 0x4001 (DeviceOptimization), 0x4002 (LocalOptimization).
+     *  - For the "Grid Energy Management" mode, tags: 0x4003 (GridOptimization).
+     *  - For the "Full Energy Management" mode, tags: 0x4001 (DeviceOptimization), 0x4002 (LocalOptimization), 0x4003 (GridOptimization).
+     */
     createDefaultDeviceEnergyManagementModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MatterbridgeDeviceEnergyManagementModeServer, {
             supportedModes: supportedModes ?? [
@@ -1131,15 +2072,27 @@ export class MatterbridgeEndpoint extends Endpoint {
                     mode: 5,
                     modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.DeviceOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }, { value: DeviceEnergyManagementMode.ModeTag.GridOptimization }],
                 },
-            ],
+            ], // Fixed attribute
             currentMode: currentMode ?? 1,
         });
         return this;
     }
+    /**
+     * Creates a default Power Topology Cluster Server with feature TreeTopology (the endpoint provides or consumes power to/from itself and its child endpoints). 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 with features ImportedEnergy, ExportedEnergy, and CumulativeEnergy.
+     *
+     * @param {number} energyImported - The total consumption value in mW/h.
+     * @param {number} energyExported - The total production value in mW/h.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     */
     createDefaultElectricalEnergyMeasurementClusterServer(energyImported = null, energyExported = null) {
         this.behaviors.require(ElectricalEnergyMeasurementServer.with(ElectricalEnergyMeasurement.Feature.ImportedEnergy, ElectricalEnergyMeasurement.Feature.ExportedEnergy, ElectricalEnergyMeasurement.Feature.CumulativeEnergy), {
             accuracy: {
@@ -1155,6 +2108,15 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default Electrical Power Measurement Cluster Server with features AlternatingCurrent.
+     *
+     * @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,
@@ -1196,36 +2158,124 @@ 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 in kPa x 10.
+     * @param {number | null} minMeasuredValue - The minimum measured value for the pressure in kPa x 10.
+     * @param {number | null} maxMeasuredValue - The maximum measured value for the pressure in kPa x 10.
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * - MeasuredValue = 10 x Pressure in kPa
+     * - MeasuredValue = 1 x Pressure in hPa
+     * - MeasuredValue = 33.8639 x Pressure in inHg
+     *
+     * Conversion:
+     * - 1 kPa = 10 hPa
+     * - 1 inHg = 33.8639 hPa
+     */
     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.
+     *
+     * @remarks 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.
+     *
+     * - 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 with feature PassiveInfrared.
+     *
+     * @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.
+     *
+     * @remarks 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 with feature NumericMeasurement.
+     *
+     * @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.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultTvocMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air, uncertainty) {
         this.behaviors.require(TotalVolatileOrganicCompoundsConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1237,6 +2287,16 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Creates a default TotalVolatileOrganicCompoundsConcentrationMeasurement cluster server with feature LevelIndication.
+     
+     * @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.
+     *
+     * @remarks
+     * The measurementMedium attribute is fixed and cannot be changed after creation.
+     */
     createLevelTvocMeasurementClusterServer(levelValue = ConcentrationMeasurement.LevelValue.Unknown, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(TotalVolatileOrganicCompoundsConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.LevelIndication, ConcentrationMeasurement.Feature.MediumLevel, ConcentrationMeasurement.Feature.CriticalLevel), {
             levelValue,
@@ -1244,6 +2304,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default CarbonMonoxideConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultCarbonMonoxideConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(CarbonMonoxideConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1255,6 +2326,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default CarbonDioxideConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultCarbonDioxideConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(CarbonDioxideConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1266,6 +2348,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default FormaldehydeConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultFormaldehydeConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(FormaldehydeConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1277,6 +2370,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default Pm1ConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultPm1ConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(Pm1ConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1288,6 +2392,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default Pm25ConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultPm25ConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(Pm25ConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1299,6 +2414,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default Pm10ConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultPm10ConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(Pm10ConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1310,6 +2436,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default OzoneConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultOzoneConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ugm3, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(OzoneConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1321,6 +2458,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default RadonConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultRadonConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ppm, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(RadonConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1332,6 +2480,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    /**
+     * Create a default NitrogenDioxideConcentrationMeasurement cluster server with feature NumericMeasurement.
+     *
+     * @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).
+     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
+     *
+     * @remarks
+     * The measurementUnit and the measurementMedium attributes are fixed and cannot be changed after creation.
+     */
     createDefaultNitrogenDioxideConcentrationMeasurementClusterServer(measuredValue = null, measurementUnit = ConcentrationMeasurement.MeasurementUnit.Ugm3, measurementMedium = ConcentrationMeasurement.MeasurementMedium.Air) {
         this.behaviors.require(NitrogenDioxideConcentrationMeasurementServer.with(ConcentrationMeasurement.Feature.NumericMeasurement), {
             measuredValue,
@@ -1344,3 +2503,4 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
 }
+//# sourceMappingURL=matterbridgeEndpoint.js.map