matterbridge 3.5.0-dev-20260117-88ddbe4 → 3.5.0

package/dist/matterbridgeEndpointHelpers.js

@@ -1,10 +1,38 @@
+/**
+ * This file contains the helpers for the class MatterbridgeEndpoint.
+ *
+ * @file matterbridgeEndpointHelpers.ts
+ * @author Luca Liguori
+ * @created 2024-10-01
+ * @version 2.1.0
+ * @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.
+ */
+// eslint-disable-next-line no-console
 if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mMatterbridgeEndpointHelpers loaded.\u001B[40;0m');
+// Other modules
 import { createHash } from 'node:crypto';
+// AnsiLogger module
 import { BLUE, CYAN, db, debugStringify, er, hk, or, YELLOW, zb } from 'node-ansi-logger';
+// @matter
 import { Lifecycle } from '@matter/general';
 import { MeasurementType } from '@matter/types/globals';
 import { getClusterNameById } from '@matter/types/cluster';
+// @matter clusters
 import { PowerSource } from '@matter/types/clusters/power-source';
 import { UserLabel } from '@matter/types/clusters/user-label';
 import { FixedLabel } from '@matter/types/clusters/fixed-label';
@@ -50,6 +78,7 @@ import { TotalVolatileOrganicCompoundsConcentrationMeasurement } from '@matter/t
 import { OperationalState } from '@matter/types/clusters/operational-state';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { DeviceEnergyManagementMode } from '@matter/types/clusters/device-energy-management-mode';
+// @matter behaviors
 import { PowerSourceServer } from '@matter/node/behaviors/power-source';
 import { UserLabelServer } from '@matter/node/behaviors/user-label';
 import { FixedLabelServer } from '@matter/node/behaviors/fixed-label';
@@ -80,63 +109,133 @@ import { Pm25ConcentrationMeasurementServer } from '@matter/node/behaviors/pm25-
 import { Pm10ConcentrationMeasurementServer } from '@matter/node/behaviors/pm10-concentration-measurement';
 import { RadonConcentrationMeasurementServer } from '@matter/node/behaviors/radon-concentration-measurement';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@matter/node/behaviors/total-volatile-organic-compounds-concentration-measurement';
+// Matterbridge
 import { deepCopy } from './utils/deepCopy.js';
 import { deepEqual } from './utils/deepEqual.js';
 import { isValidArray } from './utils/isValid.js';
 import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeDeviceEnergyManagementModeServer, } from './matterbridgeBehaviors.js';
+/**
+ *  Capitalizes the first letter of a string.
+ *
+ * @param {string} name - The string to capitalize.
+ * @returns {string} The string with the first letter capitalized.
+ */
 export function capitalizeFirstLetter(name) {
     if (!name)
         return name;
     return name.charAt(0).toUpperCase() + name.slice(1);
 }
+/**
+ * Lowercases the first letter of a string.
+ *
+ * @param {string} name - The string to lowercase the first letter of.
+ * @returns {string} The string with the first letter lowercased.
+ */
 export function lowercaseFirstLetter(name) {
     if (!name)
         return name;
     return name.charAt(0).toLowerCase() + name.slice(1);
 }
+/**
+ * Checks if the device name contains non-Latin characters.
+ *
+ * @param {string} deviceName - The name of the device to check.
+ * @returns {boolean} Returns true if the device name contains non-Latin characters, false otherwise.
+ */
 export function checkNotLatinCharacters(deviceName) {
     const nonLatinRegexList = [
-        /[\u0400-\u04FF\u0500-\u052F]/,
-        /[\u2E80-\u9FFF]/,
-        /[\uAC00-\uD7AF]/,
-        /[\u0600-\u06FF\u0750-\u077F]/,
-        /[\u0590-\u05FF]/,
-        /[\u0900-\u097F]/,
-        /[\u0E00-\u0E7F]/,
-        /[\u1200-\u137F]/,
+        /[\u0400-\u04FF\u0500-\u052F]/, // Cyrillic
+        /[\u2E80-\u9FFF]/, // CJK (Chinese, Japanese, Korean)
+        /[\uAC00-\uD7AF]/, // Korean Hangul
+        /[\u0600-\u06FF\u0750-\u077F]/, // Arabic, Persian
+        /[\u0590-\u05FF]/, // Hebrew
+        /[\u0900-\u097F]/, // Devanagari (Hindi, Sanskrit)
+        /[\u0E00-\u0E7F]/, // Thai
+        /[\u1200-\u137F]/, // Ethiopic (Amharic, Tigrinya)
     ];
     return nonLatinRegexList.some((regex) => regex.test(deviceName));
 }
+/**
+ * Generates a unique ID based on the device name.
+ *
+ * @param {string} deviceName - The name of the device to generate a unique ID for.
+ * @returns {string} A unique ID generated from the device name using MD5 hashing.
+ */
 export function generateUniqueId(deviceName) {
-    return createHash('md5').update(deviceName).digest('hex');
+    return createHash('md5').update(deviceName).digest('hex'); // MD5 hash of the device name
 }
+/**
+ * Generates a unique ID based on four parameters.
+ *
+ * @param {string} param1 - The first parameter.
+ * @param {string} param2 - The second parameter.
+ * @param {string} param3 - The third parameter.
+ * @param {string} param4 - The fourth parameter.
+ * @returns {string} A unique ID generated from the concatenation of the parameters using MD5 hashing.
+ */
 export function createUniqueId(param1, param2, param3, param4) {
     const hash = createHash('md5');
     hash.update(param1 + param2 + param3 + param4);
     return hash.digest('hex');
 }
+/**
+ * Retrieves the features for a specific behavior.
+ *
+ * @param {Endpoint} endpoint - The endpoint to retrieve the features from.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to retrieve the features for.
+ *
+ * @returns {Record<string, boolean | undefined>} The features for the specified behavior.
+ *
+ * @remarks Use with:
+ * ```typescript
+ *     expect(featuresFor(device, 'powerSource').wired).toBe(true);
+ * ```
+ */
 export function featuresFor(endpoint, cluster) {
     const behaviorId = getBehavior(endpoint, cluster)?.id;
     if (!behaviorId) {
         endpoint.log?.error(`featuresFor error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
         return {};
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return endpoint.behaviors.supported[lowercaseFirstLetter(behaviorId)]['cluster']['supportedFeatures'];
 }
+/**
+ * Maps a list of ClusterId to Behavior.Type for server clusters.
+ *
+ * @param {ClusterId[]} clusterServerList - The list of ClusterId to map.
+ * @returns {Behavior.Type[]} An array of Behavior.Type corresponding to the ClusterId in the server list.
+ */
 export function getBehaviourTypesFromClusterServerIds(clusterServerList) {
+    // Map Server ClusterId to Behavior.Type
     const behaviorTypes = [];
     clusterServerList.forEach((clusterId) => {
         behaviorTypes.push(getBehaviourTypeFromClusterServerId(clusterId));
     });
     return behaviorTypes;
 }
+/**
+ * Maps a list of ClusterId to Behavior.Type for client clusters.
+ *
+ * @param {ClusterId[]} clusterClientList - The list of ClusterId to map.
+ * @returns {Behavior.Type[]} An array of Behavior.Type corresponding to the ClusterId in the client list.
+ */
 export function getBehaviourTypesFromClusterClientIds(clusterClientList) {
+    // Map Client ClusterId to Behavior.Type
     const behaviorTypes = [];
     clusterClientList.forEach((_clusterId) => {
+        // behaviorTypes.push(getBehaviourTypeFromClusterClientId(clusterId));
     });
     return behaviorTypes;
 }
+/**
+ * Maps a ClusterId to a Behavior.Type for server clusters.
+ *
+ * @param {ClusterId} clusterId - The ClusterId to map.
+ * @returns {Behavior.Type} The corresponding Behavior.Type for the given ClusterId.
+ */
 export function getBehaviourTypeFromClusterServerId(clusterId) {
+    // Map ClusterId to Server Behavior.Type
     if (clusterId === PowerSource.Cluster.id)
         return PowerSourceServer.with(PowerSource.Feature.Wired);
     if (clusterId === UserLabel.Cluster.id)
@@ -229,8 +328,22 @@ export function getBehaviourTypeFromClusterServerId(clusterId) {
         return MatterbridgeDeviceEnergyManagementModeServer;
     return MatterbridgeIdentifyServer;
 }
+/**
+ *  Maps a ClusterId to a Behavior.Type for client clusters.
+ *
+ * @param {ClusterId} _clusterId - The ClusterId to map.
+ */
 export function getBehaviourTypeFromClusterClientId(_clusterId) {
+    // Map ClusterId to Client Behavior.Type
+    // return IdentifyClient;
 }
+/**
+ *  Retrieves the Behavior.Type for a given cluster from the endpoint's supported behaviors.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to retrieve the behavior from.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to retrieve the behavior for.
+ * @returns {Behavior.Type | undefined} The Behavior.Type for the given cluster, or undefined if not found.
+ */
 export function getBehavior(endpoint, cluster) {
     let behavior;
     if (typeof cluster === 'string') {
@@ -247,6 +360,18 @@ export function getBehavior(endpoint, cluster) {
     }
     return behavior;
 }
+/**
+ * Invokes a command on the specified behavior of the endpoint. Used ONLY in Jest tests.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to invoke the command on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to invoke the command on.
+ * @param {keyof MatterbridgeEndpointCommands} command - The command to invoke.
+ * @param {Record<string, boolean | number | bigint | string | object | null>} [params] - The parameters to pass to the command.
+ *
+ * @returns {Promise<boolean>} A promise that resolves to true if the command was invoked successfully, false otherwise.
+ *
+ * @deprecated Used ONLY in Jest tests.
+ */
 export async function invokeBehaviorCommand(endpoint, cluster, command, params) {
     const behaviorId = getBehavior(endpoint, cluster)?.id;
     if (!behaviorId) {
@@ -254,6 +379,7 @@ export async function invokeBehaviorCommand(endpoint, cluster, command, params)
         return false;
     }
     await endpoint.act((agent) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
         const behavior = agent[behaviorId];
         if (!(command in behavior) || typeof behavior[command] !== 'function') {
             endpoint.log?.error(`invokeBehaviorCommand error: command ${hk}${command}${er} not found on agent for endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
@@ -263,6 +389,19 @@ export async function invokeBehaviorCommand(endpoint, cluster, command, params)
     });
     return true;
 }
+/**
+ * Invokes the subscription handler on the specified cluster and attribute of the endpoint. Used ONLY in Jest tests.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to invoke the subscription handler on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to invoke the subscription handler on.
+ * @param {string} attribute - The attribute to invoke the subscription handler on.
+ * @param {unknown} newValue - The new value of the attribute.
+ * @param {unknown} oldValue - The old value of the attribute.
+ *
+ * @returns {Promise<boolean>} A promise that resolves to true if the subscription handler was invoked successfully, false otherwise.
+ *
+ * @deprecated Used ONLY in Jest tests.
+ */
 export async function invokeSubscribeHandler(endpoint, cluster, attribute, newValue, oldValue) {
     const event = attribute + '$Changed';
     const behaviorId = getBehavior(endpoint, cluster)?.id;
@@ -279,9 +418,17 @@ export async function invokeSubscribeHandler(endpoint, cluster, attribute, newVa
         endpoint.log.error(`invokeSubscribeHandler ${hk}${event}${er} error: cluster ${behaviorId} not found on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
         return false;
     }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
     await endpoint.act((agent) => agent[behaviorId].events[event].emit(newValue, oldValue, { ...agent.context, offline: false }));
     return true;
 }
+/**
+ * Adds required cluster servers to the specified endpoint based on the device types.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the required cluster servers to.
+ * @returns {void}
+ */
 export function addRequiredClusterServers(endpoint) {
     const requiredServerList = [];
     endpoint.log.debug(`addRequiredClusterServers for ${CYAN}${endpoint.maybeId}${db}`);
@@ -296,6 +443,12 @@ export function addRequiredClusterServers(endpoint) {
     });
     addClusterServers(endpoint, requiredServerList);
 }
+/**
+ * Adds optional cluster servers to the specified endpoint based on the device types.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the optional cluster servers to.
+ * @returns {void}
+ */
 export function addOptionalClusterServers(endpoint) {
     const optionalServerList = [];
     endpoint.log.debug(`addOptionalClusterServers for ${CYAN}${endpoint.maybeId}${db}`);
@@ -310,6 +463,12 @@ export function addOptionalClusterServers(endpoint) {
     });
     addClusterServers(endpoint, optionalServerList);
 }
+/**
+ * Adds cluster servers to the specified endpoint based on the provided server list.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the cluster servers to.
+ * @param {ClusterId[]} serverList - The list of cluster IDs to add.
+ */
 export function addClusterServers(endpoint, serverList) {
     if (serverList.includes(PowerSource.Cluster.id))
         endpoint.createDefaultPowerSourceWiredClusterServer();
@@ -392,6 +551,13 @@ export function addClusterServers(endpoint, serverList) {
     if (serverList.includes(DeviceEnergyManagementMode.Cluster.id))
         endpoint.createDefaultDeviceEnergyManagementModeClusterServer();
 }
+/**
+ * Adds a fixed label to the FixedLabel cluster. The FixedLabel cluster is created if it does not exist.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the cluster servers to.
+ * @param {string} label - The label to add. Max 16 characters.
+ * @param {string} value - The value of the label. Max 16 characters.
+ */
 export async function addFixedLabel(endpoint, label, value) {
     if (!endpoint.hasClusterServer(FixedLabel.Cluster.id)) {
         endpoint.log.debug(`addFixedLabel: add cluster ${hk}FixedLabel${db}:${hk}fixedLabel${db} with label ${CYAN}${label}${db} value ${CYAN}${value}${db}`);
@@ -408,6 +574,13 @@ export async function addFixedLabel(endpoint, label, value) {
         await endpoint.setAttribute(FixedLabel.Cluster.id, 'labelList', labelList, endpoint.log);
     }
 }
+/**
+ * Adds a user label to the UserLabel cluster. The UserLabel cluster is created if it does not exist.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the cluster servers to.
+ * @param {string} label - The label to add. Max 16 characters.
+ * @param {string} value - The value of the label. Max 16 characters.
+ */
 export async function addUserLabel(endpoint, label, value) {
     if (!endpoint.hasClusterServer(UserLabel.Cluster.id)) {
         endpoint.log.debug(`addUserLabel: add cluster ${hk}UserLabel${db}:${hk}userLabel${db} with label ${CYAN}${label}${db} value ${CYAN}${value}${db}`);
@@ -424,16 +597,48 @@ export async function addUserLabel(endpoint, label, value) {
         await endpoint.setAttribute(UserLabel.Cluster.id, 'labelList', labelList, endpoint.log);
     }
 }
+/**
+ * Returns the options for a given behavior type.
+ *
+ * @param {T} type - The behavior type.
+ * @param {Behavior.Options<T>} options - The options for the behavior type.
+ * @returns {Behavior.Options<T>} The options for the behavior type.
+ */
 export function optionsFor(type, options) {
     return options;
 }
+/**
+ * Retrieves the cluster ID.
+ *
+ * @param {Endpoint} endpoint - The endpoint to retrieve the cluster ID from.
+ * @param {ClusterId} cluster - The ID of the cluster.
+ * @returns {number | undefined} The ID of the cluster.
+ */
 export function getClusterId(endpoint, cluster) {
     return endpoint.behaviors.supported[lowercaseFirstLetter(cluster)]?.schema?.id;
 }
+/**
+ * Retrieves the ID of an attribute from a cluster behavior.
+ *
+ * @param {Endpoint} endpoint - The endpoint to retrieve the attribute ID from.
+ * @param {string} cluster - The name of the cluster.
+ * @param {string} attribute - The name of the attribute.
+ * @returns {number | undefined} The ID of the attribute, or undefined if not found.
+ */
 export function getAttributeId(endpoint, cluster, attribute) {
     const clusterBehavior = endpoint.behaviors.supported[lowercaseFirstLetter(cluster)];
     return clusterBehavior?.cluster?.attributes[lowercaseFirstLetter(attribute)]?.id;
 }
+/**
+ * Retrieves the value of the provided attribute from the given cluster.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to retrieve the attribute from.
+ * @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) The logger to use for logging the retrieve. Errors are logged to the endpoint logger.
+ * @returns {any} The value of the attribute, or undefined if the attribute is not found.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function getAttribute(endpoint, cluster, attribute, log) {
     const clusterName = getBehavior(endpoint, cluster)?.id;
     if (!clusterName) {
@@ -456,6 +661,16 @@ export function getAttribute(endpoint, cluster, attribute, log) {
     log?.info(`${db}Get endpoint ${or}${endpoint.id}${db}:${or}${endpoint.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db} value ${YELLOW}${value !== null && typeof value === 'object' ? debugStringify(value) : value}${db}`);
     return value;
 }
+/**
+ * Sets the value of an attribute on a cluster server.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to set the attribute on.
+ * @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 set. Errors are logged to the endpoint logger.
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the attribute was successfully set.
+ */
 export async function setAttribute(endpoint, cluster, attribute, value, log) {
     const clusterName = getBehavior(endpoint, cluster)?.id;
     if (!clusterName) {
@@ -481,6 +696,16 @@ export async function setAttribute(endpoint, cluster, attribute, value, log) {
         `to ${YELLOW}${value !== null && typeof value === 'object' ? debugStringify(value) : value}${db}`);
     return true;
 }
+/**
+ * Sets the value of an attribute on a cluster server.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to update the attribute on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to update 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.
+ */
 export async function updateAttribute(endpoint, cluster, attribute, value, log) {
     const clusterName = getBehavior(endpoint, cluster)?.id;
     if (!clusterName) {
@@ -511,7 +736,24 @@ export async function updateAttribute(endpoint, cluster, attribute, value, log)
         `to ${YELLOW}${value !== null && typeof value === 'object' ? debugStringify(value) : value}${db}`);
     return true;
 }
-export async function subscribeAttribute(endpoint, cluster, attribute, listener, log) {
+/**
+ * Subscribes to the provided attribute on a cluster.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to subscribe the attribute to.
+ * @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 {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.
+ */
+export async function subscribeAttribute(endpoint, cluster, attribute, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+listener, log) {
     const clusterName = getBehavior(endpoint, cluster)?.id;
     if (!clusterName) {
         endpoint.log.error(`subscribeAttribute ${hk}${attribute}${er} error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
@@ -521,6 +763,7 @@ export async function subscribeAttribute(endpoint, cluster, attribute, listener,
         endpoint.log.debug(`subscribeAttribute ${hk}${clusterName}.${attribute}${db}: Endpoint ${or}${endpoint.maybeId}${db}:${or}${endpoint.maybeNumber}${db} is in the ${BLUE}${endpoint.construction.status}${db} state`);
         await endpoint.construction.ready;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const events = endpoint.events;
     attribute = lowercaseFirstLetter(attribute) + '$Changed';
     if (!(clusterName in events) || !(attribute in events[clusterName])) {
@@ -531,6 +774,17 @@ export async function subscribeAttribute(endpoint, cluster, attribute, listener,
     log?.info(`${db}Subscribed endpoint ${or}${endpoint.id}${db}:${or}${endpoint.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db}`);
     return true;
 }
+/**
+ * Triggers an event on the specified cluster.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to trigger the event on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} 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.
+ */
 export async function triggerEvent(endpoint, cluster, event, payload, log) {
     const clusterName = getBehavior(endpoint, cluster)?.id;
     if (!clusterName) {
@@ -541,30 +795,63 @@ export async function triggerEvent(endpoint, cluster, event, payload, log) {
         endpoint.log.error(`triggerEvent ${hk}${clusterName}.${event}${er} error: Endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er} is in the ${BLUE}${endpoint.construction.status}${er} state`);
         return false;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const events = endpoint.events;
     if (!(clusterName in events) || !(event in events[clusterName])) {
         endpoint.log.error(`triggerEvent ${hk}${event}${er} error: cluster ${clusterName} not found on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
         return false;
     }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
     await endpoint.act((agent) => agent[clusterName].events[event].emit(payload, agent.context));
     log?.info(`${db}Trigger event ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${event}${db} with ${debugStringify(payload)}${db} on endpoint ${or}${endpoint.id}${db}:${or}${endpoint.number}${db} `);
     return true;
 }
+/** Utility Cluster Helpers */
+/**
+ * Get the default power source wired cluster server options.
+ *
+ * @param {PowerSource.WiredCurrentType} wiredCurrentType - The type of wired current (default: PowerSource.WiredCurrentType.Ac)
+ * @returns {Behavior.Options<PowerSourceClusterServer>} The options for the power source wired cluster server.
+ *
+ * @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).
+ */
 export function getDefaultPowerSourceWiredClusterServer(wiredCurrentType = PowerSource.WiredCurrentType.Ac) {
     return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Wired), {
+        // Base attributes
         status: PowerSource.PowerSourceStatus.Active,
         order: 0,
         description: wiredCurrentType === PowerSource.WiredCurrentType.Ac ? 'AC Power' : 'DC Power',
-        endpointList: [],
+        endpointList: [], // Will be filled by the MatterbridgePowerSourceServer
+        // Wired feature attributes
         wiredCurrentType,
     });
 }
+/**
+ * Get the default power source battery cluster server options.
+ *
+ * @param {null | number} batPercentRemaining - The remaining battery percentage (default: null). The attribute is in the range 0-200.
+ * @param {PowerSource.BatChargeLevel} batChargeLevel - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+ * @param {null | number} batVoltage - The battery voltage (default: null).
+ * @param {PowerSource.BatReplaceability} batReplaceability - The replaceability of the battery (default: PowerSource.BatReplaceability.Unspecified).
+ * @returns {Behavior.Options<PowerSourceClusterServer>} The options for the power source replaceable battery cluster server.
+ *
+ * @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.
+ */
 export function getDefaultPowerSourceBatteryClusterServer(batPercentRemaining = null, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = null, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
     return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery), {
+        // Base attributes
         status: PowerSource.PowerSourceStatus.Active,
         order: 0,
         description: 'Primary battery',
-        endpointList: [],
+        endpointList: [], // Will be filled by the MatterbridgePowerSourceServer
+        // Battery feature attributes
         batVoltage,
         batPercentRemaining: batPercentRemaining !== null ? Math.min(Math.max(batPercentRemaining * 2, 0), 200) : null,
         batChargeLevel,
@@ -572,40 +859,85 @@ export function getDefaultPowerSourceBatteryClusterServer(batPercentRemaining =
         batReplaceability,
     });
 }
+/**
+ * Get the default power source replaceable battery cluster server options.
+ *
+ * @param {number} batPercentRemaining - The remaining battery percentage (default: 100). The attribute is in the range 0-200.
+ * @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.UserReplaceable).
+ * @returns {Behavior.Options<PowerSourceClusterServer>} The options for the power source replaceable battery cluster server.
+ *
+ * @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.
+ */
 export function getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1, batReplaceability = PowerSource.BatReplaceability.UserReplaceable) {
     return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), {
+        // Base attributes
         status: PowerSource.PowerSourceStatus.Active,
         order: 0,
         description: 'Primary battery',
-        endpointList: [],
+        endpointList: [], // Will be filled by the MatterbridgePowerSourceServer
+        // Battery feature attributes
         batVoltage,
         batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
         batChargeLevel,
         batReplacementNeeded: false,
         batReplaceability,
         activeBatFaults: undefined,
+        // Replaceable feature attributes
         batReplacementDescription,
         batQuantity,
     });
 }
+/**
+ * Creates a default power source rechargeable battery cluster server.
+ *
+ * @param {number} [batPercentRemaining] - The remaining battery percentage (default: 100). The attribute is in the range 0-200.
+ * @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 {Behavior.Options<PowerSourceClusterServer>} The options for the power source rechargeable battery cluster server.
+ *
+ * @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.
+ */
 export function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
     return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), {
+        // Base attributes
         status: PowerSource.PowerSourceStatus.Active,
         order: 0,
         description: 'Primary battery',
-        endpointList: [],
+        endpointList: [], // Will be filled by the MatterbridgePowerSourceServer
+        // 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,
     });
 }
+/**
+ * Get the default Electrical Energy Measurement Cluster Server options 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 {Behavior.Options<ElectricalEnergyMeasurementServer>} - The default options for the Electrical Energy Measurement Cluster Server.
+ */
 export function getDefaultElectricalEnergyMeasurementClusterServer(energyImported = null, energyExported = null) {
     return optionsFor(ElectricalEnergyMeasurementServer.with(ElectricalEnergyMeasurement.Feature.ImportedEnergy, ElectricalEnergyMeasurement.Feature.ExportedEnergy, ElectricalEnergyMeasurement.Feature.CumulativeEnergy), {
         accuracy: {
@@ -620,6 +952,15 @@ export function getDefaultElectricalEnergyMeasurementClusterServer(energyImporte
         cumulativeEnergyExported: energyExported !== null && energyExported >= 0 ? { energy: energyExported } : null,
     });
 }
+/**
+ * Get the default Electrical Power Measurement Cluster Server options 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 {Behavior.Options<ElectricalPowerMeasurementServer>} - The default options for the Electrical Power Measurement Cluster Server.
+ */
 export function getDefaultElectricalPowerMeasurementClusterServer(voltage = null, current = null, power = null, frequency = null) {
     return optionsFor(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), {
         powerMode: ElectricalPowerMeasurement.PowerMode.Ac,
@@ -660,6 +1001,15 @@ export function getDefaultElectricalPowerMeasurementClusterServer(voltage = null
         frequency: frequency,
     });
 }
+/**
+ * Get the default Electrical Apparent Power Measurement Cluster Server with features AlternatingCurrent.
+ *
+ * @param {number} voltage - The voltage value in millivolts.
+ * @param {number} apparentCurrent - The current value in milliamperes.
+ * @param {number} apparentPower - The apparent power value in millivoltamperes.
+ * @param {number} frequency - The frequency value in millihertz.
+ * @returns {Behavior.Options<ElectricalPowerMeasurementServer>} - The default options for the Electrical Apparent Power Measurement Cluster Server.
+ */
 export function getApparentElectricalPowerMeasurementClusterServer(voltage = null, apparentCurrent = null, apparentPower = null, frequency = null) {
     return optionsFor(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), {
         powerMode: ElectricalPowerMeasurement.PowerMode.Ac,
@@ -700,19 +1050,55 @@ export function getApparentElectricalPowerMeasurementClusterServer(voltage = nul
         frequency: frequency,
     });
 }
+/**
+ * Get the 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 {Behavior.Options<DeviceEnergyManagementClusterServer>} - The default options for the Device Energy Management Cluster Server.
+ *
+ * @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.
+ */
 export function getDefaultDeviceEnergyManagementClusterServer(esaType = DeviceEnergyManagement.EsaType.Other, esaCanGenerate = false, esaState = DeviceEnergyManagement.EsaState.Online, absMinPower = 0, absMaxPower = 0) {
     return optionsFor(MatterbridgeDeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment), {
-        esaType,
-        esaCanGenerate,
+        esaType, // Fixed attribute
+        esaCanGenerate, // Fixed attribute
         esaState,
         absMinPower,
         absMaxPower,
-        powerAdjustmentCapability: null,
+        // PowerAdjustment feature (commands: powerAdjustRequest and cancelPowerAdjustRequest events: powerAdjustStart and powerAdjustEnd)
+        powerAdjustmentCapability: null, // A null value indicates that no power adjustment is currently possible, and nor is any adjustment currently active
         optOutState: DeviceEnergyManagement.OptOutState.NoOptOut,
-        forecast: null,
+        // PowerForecastReporting
+        forecast: null, // A null value indicates that there is no forecast currently available
     });
 }
+/**
+ * Get the 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 {Behavior.Options<DeviceEnergyManagementModeClusterServer>} - The default options for the Device Energy Management Mode cluster server.
+ *
+ * @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).
+ */
 export function getDefaultDeviceEnergyManagementModeClusterServer(currentMode, supportedModes) {
+    // TODO: matter.js 0.16.0 needs a with() method
     return optionsFor(MatterbridgeDeviceEnergyManagementModeServer.with(), {
         supportedModes: supportedModes ?? [
             { label: 'No Energy Management (Forecast reporting only)', mode: 1, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.NoOptimization }] },
@@ -732,11 +1118,26 @@ export function getDefaultDeviceEnergyManagementModeClusterServer(currentMode, s
                 mode: 5,
                 modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.DeviceOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }, { value: DeviceEnergyManagementMode.ModeTag.GridOptimization }],
             },
-        ],
+        ], // Fixed attribute
         currentMode: currentMode ?? 1,
     });
 }
+/** Application Cluster Helpers */
+/**
+ * Get the default OperationalState Cluster Server.
+ *
+ * @param {OperationalState.OperationalStateEnum} operationalState - The initial operational state id.
+ * @returns {Behavior.Options<MatterbridgeOperationalStateServer>} - The default options for the OperationalState cluster server.
+ *
+ * @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' },
+ */
 export function getDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+    // TODO: matter.js 0.16.0 needs a with() method
     return optionsFor(MatterbridgeOperationalStateServer.with(), {
         phaseList: [],
         currentPhase: null,
@@ -751,6 +1152,14 @@ export function getDefaultOperationalStateClusterServer(operationalState = Opera
         operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
     });
 }
+/**
+ * Get the default TemperatureMeasurement cluster server options.
+ *
+ * @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 {Behavior.Options<MatterbridgeTemperatureMeasurementServer>} - The default options for the TemperatureMeasurement cluster server.
+ */
 export function getDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
     return optionsFor(TemperatureMeasurementServer, {
         measuredValue,
@@ -759,6 +1168,14 @@ export function getDefaultTemperatureMeasurementClusterServer(measuredValue = nu
         tolerance: 0,
     });
 }
+/**
+ * Get the default RelativeHumidityMeasurement cluster server options.
+ *
+ * @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 {Behavior.Options<MatterbridgeRelativeHumidityMeasurementServer>} - The default options for the RelativeHumidityMeasurement cluster server.
+ */
 export function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
     return optionsFor(RelativeHumidityMeasurementServer, {
         measuredValue,
@@ -767,6 +1184,14 @@ export function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue
         tolerance: 0,
     });
 }
+/**
+ * Get the default PressureMeasurement cluster server options.
+ *
+ * @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 {Behavior.Options<MatterbridgePressureMeasurementServer>} - The default options for the PressureMeasurement cluster server.
+ */
 export function getDefaultPressureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
     return optionsFor(PressureMeasurementServer, {
         measuredValue,
@@ -775,6 +1200,21 @@ export function getDefaultPressureMeasurementClusterServer(measuredValue = null,
         tolerance: 0,
     });
 }
+/**
+ * Get the default IlluminanceMeasurement cluster server options.
+ *
+ * @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 {Behavior.Options<MatterbridgeIlluminanceMeasurementServer>} - The default options for the IlluminanceMeasurement cluster server.
+ *
+ * @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.
+ */
 export function getDefaultIlluminanceMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
     return optionsFor(IlluminanceMeasurementServer, {
         measuredValue,
@@ -783,6 +1223,14 @@ export function getDefaultIlluminanceMeasurementClusterServer(measuredValue = nu
         tolerance: 0,
     });
 }
+/**
+ * Get the default FlowMeasurement cluster server options.
+ *
+ * @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 {Behavior.Options<MatterbridgeFlowMeasurementServer>} - The default options for the FlowMeasurement cluster server.
+ */
 export function getDefaultFlowMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
     return optionsFor(FlowMeasurementServer, {
         measuredValue,
@@ -791,6 +1239,20 @@ export function getDefaultFlowMeasurementClusterServer(measuredValue = null, min
         tolerance: 0,
     });
 }
+/**
+ * Get the default OccupancySensing cluster server options.
+ *
+ * @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 {Behavior.Options<MatterbridgeOccupancySensingServer>} - The default options for the OccupancySensing cluster server.
+ *
+ * @remarks The default value for the occupancy sensor type is PIR.
+ * Servers SHALL set these attributes for backward compatibility with clients implementing a cluster revision <= 4 as
+ * described in OccupancySensorType and OccupancySensorTypeBitmap Attributes.
+ * This replaces the 9 legacy attributes PIROccupiedToUnoccupiedDelay through PhysicalContactUnoccupiedToOccupiedThreshold.
+ */
 export function getDefaultOccupancySensingClusterServer(occupied = false, holdTime = 30, holdTimeMin = 1, holdTimeMax = 300) {
     return optionsFor(OccupancySensingServer.with(OccupancySensing.Feature.PassiveInfrared), {
         occupancy: { occupied },
@@ -803,3 +1265,4 @@ export function getDefaultOccupancySensingClusterServer(occupied = false, holdTi
         holdTimeLimits: { holdTimeMin, holdTimeMax, holdTimeDefault: holdTime },
     });
 }
+//# sourceMappingURL=matterbridgeEndpointHelpers.js.map