matterbridge 1.3.10 → 1.3.12

package/dist/matterbridgeDevice.js

@@ -20,8 +20,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License. *
  */
-import { BasicInformationCluster, BooleanState, BooleanStateCluster, ClusterServer, ColorControl, ColorControlCluster, DoorLock, DoorLockCluster, ElectricalMeasurement, ElectricalMeasurementCluster, FanControl, FanControlCluster, FixedLabelCluster, FlowMeasurement, FlowMeasurementCluster, Groups, Identify, IdentifyCluster, IlluminanceMeasurement, IlluminanceMeasurementCluster, LevelControl, LevelControlCluster, ModeSelectCluster, OccupancySensing, OccupancySensingCluster, OnOff, OnOffCluster, PowerSource, PowerSourceCluster, PowerSourceConfigurationCluster, PressureMeasurement, PressureMeasurementCluster, RelativeHumidityMeasurement, RelativeHumidityMeasurementCluster, Scenes, Switch, SwitchCluster, TemperatureMeasurement, TemperatureMeasurementCluster, Thermostat, ThermostatCluster, ThreadNetworkDiagnostics, ThreadNetworkDiagnosticsCluster, TimeSync, TimeSyncCluster, WindowCovering, WindowCoveringCluster, createDefaultGroupsClusterServer, createDefaultScenesClusterServer, getClusterNameById, } from '@project-chip/matter-node.js/cluster';
-import { EndpointNumber, VendorId } from '@project-chip/matter-node.js/datatype';
+import { BasicInformationCluster, BooleanState, BooleanStateCluster, ClusterServer, ColorControl, ColorControlCluster, DoorLock, DoorLockCluster, ElectricalMeasurement, ElectricalMeasurementCluster, FanControl, FanControlCluster, FixedLabelCluster, FlowMeasurement, FlowMeasurementCluster, Groups, GroupsCluster, GroupsClusterHandler, Identify, IdentifyCluster, IlluminanceMeasurement, IlluminanceMeasurementCluster, LevelControl, LevelControlCluster, ModeSelectCluster, OccupancySensing, OccupancySensingCluster, OnOff, OnOffCluster, PowerSource, PowerSourceCluster, PowerSourceConfigurationCluster, PressureMeasurement, PressureMeasurementCluster, RelativeHumidityMeasurement, RelativeHumidityMeasurementCluster, Scenes, ScenesCluster, ScenesClusterHandler, Switch, SwitchCluster, TemperatureMeasurement, TemperatureMeasurementCluster, Thermostat, ThermostatCluster, ThreadNetworkDiagnostics, ThreadNetworkDiagnosticsCluster, TimeSync, TimeSyncCluster, WindowCovering, WindowCoveringCluster, getClusterNameById, } from '@project-chip/matter-node.js/cluster';
+import { EndpointNumber, GroupId, VendorId } from '@project-chip/matter-node.js/datatype';
 import { Device, DeviceClasses, DeviceTypeDefinition, Endpoint } from '@project-chip/matter-node.js/device';
 import { extendPublicHandlerMethods } from '@project-chip/matter-node.js/util';
 import { EveHistory, EveHistoryCluster } from 'matter-history';
@@ -169,28 +169,110 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     /**
      * Create a Matterbridge device.
      * @constructor
-     * @param {DeviceTypeDefinition} definition - The definition of the device.
+     * @param {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The DeviceTypeDefinition of the device.
      * @param {EndpointOptions} [options={}] - The options for the device.
+     * @param {boolean} [debug=false] - The debug level for the device.
      */
     constructor(definition, options = {}, debug = false) {
-        super(definition, options);
+        let firstDefinition;
+        if (Array.isArray(definition))
+            firstDefinition = definition[0];
+        else
+            firstDefinition = definition;
+        super(firstDefinition, options);
         this.log = new AnsiLogger({ logName: 'MatterbridgeDevice', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: debug });
-        this.log.debug(`MatterbridgeDevice with deviceType: ${zb}${definition.code}${db}-${zb}${definition.name}${db}`);
+        this.log.debug(`new MatterbridgeDevice with deviceType: ${zb}${firstDefinition.code}${db}-${zb}${firstDefinition.name}${db}`);
+        if (Array.isArray(definition)) {
+            definition.forEach((deviceType) => {
+                this.addDeviceType(deviceType);
+            });
+        }
+        this.addDeviceType(firstDefinition);
     }
     /**
-     * Loads an instance of the MatterbridgeDevice class.
+     * Loads asyncronously an instance of the MatterbridgeDevice class.
      *
-     * @param {DeviceTypeDefinition} definition - The DeviceTypeDefinition of the device.
-     * @returns MatterbridgeDevice instance.
+     * @param {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The DeviceTypeDefinition of the device.
+     * @param {EndpointOptions} [options={}] - The options for the device.
+     * @param {boolean} [debug=false] - The debug level for the device.
+     * @returns {Promise<MatterbridgeDevice>} A Promise of MatterbridgeDevice instance.
      */
     static async loadInstance(definition, options = {}, debug = false) {
         return new MatterbridgeDevice(definition, options, debug);
     }
+    /**
+     * Create asyncronously a device with one or more device types and with the required cluster servers and the specified cluster servers.
+     *
+     * @param {DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>} definition - The device types to add.
+     * @param {EndpointOptions} [options={}] - The options for the device.
+     * @param {ClusterId[]} clusterServerList - The list of cluster IDs to include.
+     * @param {boolean} [debug=false] - The debug level for the device.
+     * @returns {Promise<MatterbridgeDevice>} The MatterbridgeDevice instance.
+     *
+    static async createWithClusterServer(definition: DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>, options: EndpointOptions = {}, clusterServerList: ClusterId[] = [], debug = false): Promise<MatterbridgeDevice> {
+      const device = new MatterbridgeDevice(definition, options, debug);
+      if (Array.isArray(definition)) {
+        definition.forEach((deviceType) => {
+          deviceType.requiredServerClusters.forEach((clusterId) => {
+            if (!clusterServerList.includes(clusterId)) clusterServerList.push(clusterId);
+          });
+        });
+      } else {
+        definition.requiredServerClusters.forEach((clusterId) => {
+          if (!clusterServerList.includes(clusterId)) clusterServerList.push(clusterId);
+        });
+      }
+      device.log.debug(`createWithClusterServer:`);
+      const deviceTypes = device.getDeviceTypes();
+      deviceTypes.forEach((deviceType) => {
+        device.log.debug(`- with deviceType: ${zb}${deviceType.code}${db}-${zb}${deviceType.name}${db}`);
+      });
+      clusterServerList.forEach((clusterId) => {
+        device.log.debug(`- with cluster: ${hk}${clusterId}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
+      });
+      device.addClusterServerFromList(device, clusterServerList);
+      // TODO must by typed and tested
+      Object.entries(options).forEach(([key, value]) => {
+        if (key === 'basicInformation') {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const basicInformation = value as any;
+          device.createDefaultBasicInformationClusterServer(
+            basicInformation.deviceName,
+            basicInformation.serialNumber,
+            basicInformation.vendorId,
+            basicInformation.vendorName,
+            basicInformation.productId,
+            basicInformation.productName,
+            basicInformation.softwareVersion,
+            basicInformation.softwareVersionString,
+            basicInformation.hardwareVersion,
+            basicInformation.hardwareVersionString,
+          );
+        } else if (key === 'bridgedDeviceBasicInformation') {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const bridgedDeviceBasicInformation = value as any;
+          device.createDefaultBridgedDeviceBasicInformationClusterServer(
+            bridgedDeviceBasicInformation.deviceName,
+            bridgedDeviceBasicInformation.serialNumber,
+            bridgedDeviceBasicInformation.vendorId,
+            bridgedDeviceBasicInformation.vendorName,
+            bridgedDeviceBasicInformation.productName,
+            bridgedDeviceBasicInformation.softwareVersion,
+            bridgedDeviceBasicInformation.softwareVersionString,
+            bridgedDeviceBasicInformation.hardwareVersion,
+            bridgedDeviceBasicInformation.hardwareVersionString,
+          );
+        }
+      });
+      return device;
+    }
+    */
     /**
      * Adds a device type to the list of device types of the MatterbridgeDevice endpoint.
      * If the device type is not already present in the list, it will be added.
      *
      * @param {DeviceTypeDefinition} deviceType - The device type to add.
+     * @returns {MatterbridgeDevice} The MatterbridgeDevice instance.
      */
     addDeviceType(deviceType) {
         const deviceTypes = this.getDeviceTypes();
@@ -199,14 +281,16 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             deviceTypes.push(deviceType);
             this.setDeviceTypes(deviceTypes);
         }
+        return this;
     }
     /**
      * Adds one or more device types with the required cluster servers and the specified cluster servers.
      *
      * @param {AtLeastOne<DeviceTypeDefinition>} deviceTypes - The device types to add.
      * @param {ClusterId[]} includeServerList - The list of cluster IDs to include.
+     * @returns {MatterbridgeDevice} The MatterbridgeDevice instance.
      */
-    addDeviceTypeWithClusterServer(deviceTypes, includeServerList) {
+    addDeviceTypeWithClusterServer(deviceTypes, includeServerList = []) {
         this.log.debug('addDeviceTypeWithClusterServer:');
         deviceTypes.forEach((deviceType) => {
             this.addDeviceType(deviceType);
@@ -220,6 +304,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             this.log.debug(`- with cluster: ${hk}${clusterId}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
         });
         this.addClusterServerFromList(this, includeServerList);
+        return this;
     }
     /**
      * Adds a child endpoint with one or more device types with the required cluster servers and the specified cluster servers.
@@ -231,12 +316,13 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
      * @param {ClusterId[]} includeServerList - The list of cluster IDs to include.
      * @returns {Endpoint} - The child endpoint that was found or added.
      */
-    addChildDeviceTypeWithClusterServer(endpointName, deviceTypes, includeServerList) {
+    addChildDeviceTypeWithClusterServer(endpointName, deviceTypes, includeServerList = []) {
         this.log.debug(`addChildDeviceTypeWithClusterServer: ${CYAN}${endpointName}${db}`);
         let child = this.getChildEndpoints().find((endpoint) => endpoint.uniqueStorageKey === endpointName);
         if (!child) {
             child = new Endpoint(deviceTypes, { uniqueStorageKey: endpointName });
             child.addFixedLabel('endpointName', endpointName);
+            this.addChildEndpoint(child);
         }
         deviceTypes.forEach((deviceType) => {
             this.log.debug(`- with deviceType: ${zb}${deviceType.code}${db}-${zb}${deviceType.name}${db}`);
@@ -248,16 +334,65 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
         includeServerList.forEach((clusterId) => {
             this.log.debug(`- with cluster: ${hk}${clusterId}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
         });
+        const childDeviceTypes = child.getDeviceTypes();
+        deviceTypes.forEach((deviceType) => {
+            if (!childDeviceTypes.includes(deviceType))
+                childDeviceTypes.push(deviceType);
+        });
+        child.setDeviceTypes(childDeviceTypes);
         this.addClusterServerFromList(child, includeServerList);
-        this.addChildEndpoint(child);
         return child;
     }
+    /**
+     * Adds the required cluster servers (only if they are not present) for the device types of the specified endpoint.
+     *
+     * @param {Endpoint} endpoint - The endpoint to add the required cluster servers to.
+     * @returns {Endpoint} The updated endpoint with the required cluster servers added.
+     */
+    addRequiredClusterServers(endpoint) {
+        const requiredServerList = [];
+        this.log.debug(`addRequiredClusterServer for ${CYAN}${endpoint.name}${db}`);
+        endpoint.getDeviceTypes().forEach((deviceType) => {
+            this.log.debug(`- for deviceType: ${zb}${deviceType.code}${db}-${zb}${deviceType.name}${db}`);
+            deviceType.requiredServerClusters.forEach((clusterId) => {
+                if (!requiredServerList.includes(clusterId) && !endpoint.getClusterClientById(clusterId))
+                    requiredServerList.push(clusterId);
+            });
+        });
+        requiredServerList.forEach((clusterId) => {
+            this.log.debug(`- with cluster: ${hk}${clusterId}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
+        });
+        this.addClusterServerFromList(endpoint, requiredServerList);
+        return endpoint;
+    }
+    /**
+     * Adds the optional cluster servers (only if they are not present) for the device types of the specified endpoint.
+     *
+     * @param {Endpoint} endpoint - The endpoint to add the required cluster servers to.
+     * @returns {Endpoint} The updated endpoint with the required cluster servers added.
+     */
+    addOptionalClusterServers(endpoint) {
+        const optionalServerList = [];
+        this.log.debug(`addRequiredClusterServer for ${CYAN}${endpoint.name}${db}`);
+        endpoint.getDeviceTypes().forEach((deviceType) => {
+            this.log.debug(`- for deviceType: ${zb}${deviceType.code}${db}-${zb}${deviceType.name}${db}`);
+            deviceType.optionalServerClusters.forEach((clusterId) => {
+                if (!optionalServerList.includes(clusterId) && !endpoint.getClusterClientById(clusterId))
+                    optionalServerList.push(clusterId);
+            });
+        });
+        optionalServerList.forEach((clusterId) => {
+            this.log.debug(`- with cluster: ${hk}${clusterId}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
+        });
+        this.addClusterServerFromList(endpoint, optionalServerList);
+        return endpoint;
+    }
     /**
      * Adds cluster servers to the specified endpoint based on the provided server list.
      *
      * @param {Endpoint} endpoint - The endpoint to add cluster servers to.
      * @param {ClusterId[]} includeServerList - The list of cluster IDs to include.
-     * @returns void
+     * @returns {Endpoint} The updated endpoint with the cluster servers added.
      */
     addClusterServerFromList(endpoint, includeServerList) {
         if (includeServerList.includes(Identify.Cluster.id))
@@ -340,6 +475,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             endpoint.addClusterServer(this.getDefaultDeviceEnergyManagementClusterServer());
         if (includeServerList.includes(DeviceEnergyManagementMode.Cluster.id))
             endpoint.addClusterServer(this.getDefaultDeviceEnergyManagementModeClusterServer());
+        return endpoint;
     }
     /**
      * Retrieves a child endpoint by its name.
@@ -348,16 +484,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
      * @returns {Endpoint | undefined} The child endpoint with the specified name, or undefined if not found.
      */
     getChildEndpointByName(endpointName) {
-        for (const child of this.getChildEndpoints()) {
-            // Find the endpoint name (l1...)
-            const labelList = child.getClusterServer(FixedLabelCluster)?.getLabelListAttribute();
-            if (!labelList)
-                continue;
-            const value = labelList.find((entry) => entry.label === 'endpointName');
-            if (value && value.value === endpointName)
-                return child;
-        }
-        return undefined;
+        return this.getChildEndpoints().find((endpoint) => endpoint.uniqueStorageKey === endpointName);
     }
     /**
      * Retrieves a child endpoint name.
@@ -373,7 +500,6 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
         const endpointNameLabel = labelList.find((entry) => entry.label === 'endpointName');
         if (endpointNameLabel)
             return endpointNameLabel.value;
-        return undefined;
     }
     /**
      * Sets the endpoint name for a child endpoint.
@@ -399,7 +525,6 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             if (entry.label === 'endpointName')
                 return entry.value;
         }
-        return undefined;
     }
     /**
      * Retrieves the child endpoint with the specified label.
@@ -408,8 +533,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
      * @returns {Endpoint | undefined} The child endpoint with the specified label, or undefined if not found.
      */
     getChildEndpointWithLabel(label) {
-        const endpoints = this.getChildEndpoints();
-        for (const endpoint of endpoints) {
+        for (const endpoint of this.getChildEndpoints()) {
             const labelList = endpoint.getClusterServer(FixedLabelCluster)?.getLabelListAttribute();
             if (!labelList)
                 return undefined;
@@ -421,7 +545,6 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             if (endpointName === label)
                 return endpoint;
         }
-        return undefined;
     }
     /**
      * Serializes the Matterbridge device into a serialized object.
@@ -432,11 +555,18 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     serialize(pluginName) {
         if (!this.serialNumber || !this.deviceName || !this.uniqueId)
             return;
+        const cluster = this.getClusterServer(BasicInformationCluster) ?? this.getClusterServer(BridgedDeviceBasicInformationCluster);
+        if (!cluster)
+            return;
         const serialized = {
             pluginName,
             serialNumber: this.serialNumber,
             deviceName: this.deviceName,
             uniqueId: this.uniqueId,
+            productId: cluster.attributes.productId?.getLocal(),
+            productName: cluster.attributes.productName?.getLocal(),
+            vendorId: cluster.attributes.vendorId?.getLocal(),
+            vendorName: cluster.attributes.vendorName?.getLocal(),
             deviceTypes: this.getDeviceTypes(),
             endpoint: this.number,
             endpointName: this.name,
@@ -447,6 +577,27 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
         });
         return serialized;
     }
+    /**
+     * Serializes the Matterbridge device into a serialized object.
+     *
+     * @param pluginName - The name of the plugin.
+     * @returns The serialized Matterbridge device object.
+     */
+    static deserialize(serializedDevice) {
+        const device = new MatterbridgeDevice(serializedDevice.deviceTypes);
+        device.serialNumber = serializedDevice.serialNumber;
+        device.deviceName = serializedDevice.deviceName;
+        device.uniqueId = serializedDevice.uniqueId;
+        for (const clusterId of serializedDevice.clusterServersId) {
+            if (clusterId === BasicInformationCluster.id)
+                device.createDefaultBasicInformationClusterServer(serializedDevice.deviceName, serializedDevice.serialNumber, serializedDevice.vendorId ?? 0xfff1, serializedDevice.vendorName ?? 'Matterbridge', serializedDevice.productId ?? 0x8000, serializedDevice.productName ?? 'Matterbridge device');
+            else if (clusterId === BridgedDeviceBasicInformationCluster.id)
+                device.createDefaultBridgedDeviceBasicInformationClusterServer(serializedDevice.deviceName, serializedDevice.serialNumber, serializedDevice.vendorId ?? 0xfff1, serializedDevice.vendorName ?? 'Matterbridge', serializedDevice.productName ?? 'Matterbridge device');
+            else
+                device.addClusterServerFromList(device, [clusterId]);
+        }
+        return device;
+    }
     /**
      * Returns a default static EveHistoryClusterServer object with the specified voltage, current, power, and consumption values.
      * This shows up in HA as a static sensor!
@@ -467,7 +618,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             HistorySetTime: Uint8Array.fromHex(''),
             LastEvent: 0,
             ResetTotal: 0,
-            // Normal attributes
+            // Normal static attributes
             Voltage: voltage,
             Current: current,
             Consumption: power,
@@ -477,6 +628,18 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             RLoc: 46080,
         }, {}, {});
     }
+    /**
+     * Create a default static EveHistoryClusterServer object with the specified voltage, current, power, and consumption values.
+     * This shows up in HA as a static sensor!
+     * @param voltage - The voltage value (default: 0).
+     * @param current - The current value (default: 0).
+     * @param power - The power value (default: 0).
+     * @param consumption - The consumption value (default: 0).
+     * @returns The default static EveHistoryClusterServer object.
+     */
+    createDefaultStaticEveHistoryClusterServer(voltage = 0, current = 0, power = 0, consumption = 0) {
+        this.addClusterServer(this.getDefaultStaticEveHistoryClusterServer(voltage, current, power, consumption));
+    }
     /**
      * Creates a room Eve History Cluster Server.
      *
@@ -815,28 +978,37 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     /**
      * Get a default IdentifyCluster server.
      */
-    getDefaultIdentifyClusterServer() {
+    getDefaultIdentifyClusterServer(identifyTime = 0, identifyType = Identify.IdentifyType.None) {
         return ClusterServer(IdentifyCluster, {
-            identifyTime: 0,
-            identifyType: Identify.IdentifyType.None,
+            identifyTime,
+            identifyType,
         }, {
             identify: async (data) => {
                 this.log.debug('Matter command: Identify');
                 await this.commandHandler.executeHandler('identify', data);
             },
+            triggerEffect: async (data) => {
+                this.log.debug('Matter command: TriggerEffect');
+                await this.commandHandler.executeHandler('triggerEffect', data);
+            },
         });
     }
     /**
      * Creates a default IdentifyCluster server.
      */
-    createDefaultIdentifyClusterServer() {
-        this.addClusterServer(this.getDefaultIdentifyClusterServer());
+    createDefaultIdentifyClusterServer(identifyTime = 0, identifyType = Identify.IdentifyType.None) {
+        this.addClusterServer(this.getDefaultIdentifyClusterServer(identifyTime, identifyType));
     }
     /**
      * Get a default IdentifyCluster server.
      */
     getDefaultGroupsClusterServer() {
-        return createDefaultGroupsClusterServer();
+        return ClusterServer(GroupsCluster, {
+            nameSupport: {
+                nameSupport: true,
+            },
+        }, GroupsClusterHandler());
+        // return createDefaultGroupsClusterServer();
     }
     /**
      * Creates a default groups cluster server and adds it to the device.
@@ -848,7 +1020,17 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
      * Get a default scenes cluster server and adds it to the current instance.
      */
     getDefaultScenesClusterServer() {
-        return createDefaultScenesClusterServer();
+        return ClusterServer(ScenesCluster, {
+            sceneCount: 0,
+            currentScene: 0,
+            currentGroup: GroupId(0),
+            sceneValid: false,
+            nameSupport: {
+                nameSupport: true,
+            },
+            lastConfiguredBy: null,
+        }, ScenesClusterHandler());
+        // return createDefaultScenesClusterServer();
     }
     /**
      * Creates a default scenes cluster server and adds it to the current instance.
@@ -1079,6 +1261,7 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     }
     /**
      * Creates a default Dummy Thread Network Diagnostics Cluster server.
+     * @deprecated This method is deprecated and is only for testing.
      *
      * @remarks
      * This method adds a cluster server used only to give the networkName to Eve app.
@@ -1276,6 +1459,8 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     /**
      * Get a default color control cluster server.
      *
+     * @param currentX - The current X value.
+     * @param currentY - The current Y value.
      * @param currentHue - The current hue value.
      * @param currentSaturation - The current saturation value.
      * @param colorTemperatureMireds - The color temperature in mireds.
@@ -1351,6 +1536,8 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
     /**
      * Creates a default color control cluster server.
      *
+     * @param currentX - The current X value.
+     * @param currentY - The current Y value.
      * @param currentHue - The current hue value.
      * @param currentSaturation - The current saturation value.
      * @param colorTemperatureMireds - The color temperature in mireds.
@@ -1590,6 +1777,17 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
         this.addFixedLabel('orientation', 'Switch');
         this.addFixedLabel('label', 'Switch');
     }
+    /**
+     * Retrieves the default mode select cluster server.
+     *
+     * @deprecated This method is currently under development and should not be used.
+     *
+     * @param description - The description of the cluster server.
+     * @param supportedModes - The supported modes for the cluster server.
+     * @param currentMode - The current mode of the cluster server. Defaults to 0.
+     * @param startUpMode - The startup mode of the cluster server. Defaults to 0.
+     * @returns The default mode select cluster server.
+     */
     getDefaultModeSelectClusterServer(description, supportedModes, currentMode = 0, startUpMode = 0) {
         return ClusterServer(ModeSelectCluster, {
             description: description,
@@ -1604,6 +1802,16 @@ export class MatterbridgeDevice extends extendPublicHandlerMethods(Device) {
             },
         });
     }
+    /**
+     * Creates a default mode select cluster server.
+     *
+     * @remarks
+     * This method adds a cluster server for a mode select cluster with default settings.
+     *
+     * @deprecated This method is currently under development and should not be used.
+     *
+     * @param endpoint - The endpoint to add the cluster server to. Defaults to `this` if not provided.
+     */
     createDefaultModeSelectClusterServer(endpoint) {
         if (!endpoint)
             endpoint = this;