matterbridge 2.1.0-dev.1 → 2.1.0-dev.10

package/dist/matterbridgeEndpoint.js

@@ -1,18 +1,14 @@
-import { createHash } from 'crypto';
 import { AnsiLogger, BLUE, CYAN, YELLOW, db, debugStringify, er, hk, or, zb } from './logger/export.js';
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
-import { deepCopy, isValidNumber } from './utils/utils.js';
-import { MatterbridgeBehavior, MatterbridgeBehaviorDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, } from './matterbridgeBehaviors.js';
+import { isValidNumber, isValidObject } from './utils/utils.js';
+import { MatterbridgeBehavior, MatterbridgeBehaviorDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, } from './matterbridgeBehaviors.js';
+import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, capitalizeFirstLetter, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, } from './matterbridgeEndpointHelpers.js';
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, VendorId } from '@matter/main';
 import { getClusterNameById, MeasurementType } from '@matter/main/types';
 import { Descriptor } from '@matter/main/clusters/descriptor';
 import { PowerSource } from '@matter/main/clusters/power-source';
-import { UserLabel } from '@matter/main/clusters/user-label';
-import { FixedLabel } from '@matter/main/clusters/fixed-label';
-import { BasicInformation } from '@matter/main/clusters/basic-information';
 import { BridgedDeviceBasicInformation } from '@matter/main/clusters/bridged-device-basic-information';
 import { Identify } from '@matter/main/clusters/identify';
-import { Groups } from '@matter/main/clusters/groups';
 import { OnOff } from '@matter/main/clusters/on-off';
 import { LevelControl } from '@matter/main/clusters/level-control';
 import { ColorControl } from '@matter/main/clusters/color-control';
@@ -20,39 +16,18 @@ import { WindowCovering } from '@matter/main/clusters/window-covering';
 import { Thermostat } from '@matter/main/clusters/thermostat';
 import { FanControl } from '@matter/main/clusters/fan-control';
 import { DoorLock } from '@matter/main/clusters/door-lock';
-import { ModeSelect } from '@matter/main/clusters/mode-select';
 import { ValveConfigurationAndControl } from '@matter/main/clusters/valve-configuration-and-control';
 import { PumpConfigurationAndControl } from '@matter/main/clusters/pump-configuration-and-control';
 import { SmokeCoAlarm } from '@matter/main/clusters/smoke-co-alarm';
 import { Switch } from '@matter/main/clusters/switch';
-import { BooleanState } from '@matter/main/clusters/boolean-state';
 import { BooleanStateConfiguration } from '@matter/main/clusters/boolean-state-configuration';
 import { PowerTopology } from '@matter/main/clusters/power-topology';
 import { ElectricalPowerMeasurement } from '@matter/main/clusters/electrical-power-measurement';
 import { ElectricalEnergyMeasurement } from '@matter/main/clusters/electrical-energy-measurement';
-import { TemperatureMeasurement } from '@matter/main/clusters/temperature-measurement';
-import { RelativeHumidityMeasurement } from '@matter/main/clusters/relative-humidity-measurement';
-import { PressureMeasurement } from '@matter/main/clusters/pressure-measurement';
-import { FlowMeasurement } from '@matter/main/clusters/flow-measurement';
-import { IlluminanceMeasurement } from '@matter/main/clusters/illuminance-measurement';
-import { OccupancySensing } from '@matter/main/clusters/occupancy-sensing';
 import { AirQuality } from '@matter/main/clusters/air-quality';
-import { CarbonMonoxideConcentrationMeasurement } from '@matter/main/clusters/carbon-monoxide-concentration-measurement';
-import { CarbonDioxideConcentrationMeasurement } from '@matter/main/clusters/carbon-dioxide-concentration-measurement';
-import { NitrogenDioxideConcentrationMeasurement } from '@matter/main/clusters/nitrogen-dioxide-concentration-measurement';
-import { OzoneConcentrationMeasurement } from '@matter/main/clusters/ozone-concentration-measurement';
-import { FormaldehydeConcentrationMeasurement } from '@matter/main/clusters/formaldehyde-concentration-measurement';
-import { Pm1ConcentrationMeasurement } from '@matter/main/clusters/pm1-concentration-measurement';
-import { Pm25ConcentrationMeasurement } from '@matter/main/clusters/pm25-concentration-measurement';
-import { Pm10ConcentrationMeasurement } from '@matter/main/clusters/pm10-concentration-measurement';
-import { RadonConcentrationMeasurement } from '@matter/main/clusters/radon-concentration-measurement';
-import { TotalVolatileOrganicCompoundsConcentrationMeasurement } from '@matter/main/clusters/total-volatile-organic-compounds-concentration-measurement';
 import { ConcentrationMeasurement } from '@matter/main/clusters/concentration-measurement';
 import { DescriptorServer } from '@matter/main/behaviors/descriptor';
 import { PowerSourceServer } from '@matter/main/behaviors/power-source';
-import { UserLabelServer } from '@matter/main/behaviors/user-label';
-import { FixedLabelServer } from '@matter/main/behaviors/fixed-label';
-import { BasicInformationServer } from '@matter/main/behaviors/basic-information';
 import { BridgedDeviceBasicInformationServer } from '@matter/main/behaviors/bridged-device-basic-information';
 import { GroupsServer } from '@matter/main/behaviors/groups';
 import { ScenesManagementServer } from '@matter/main/behaviors/scenes-management';
@@ -79,242 +54,6 @@ import { Pm25ConcentrationMeasurementServer } from '@matter/main/behaviors/pm25-
 import { Pm10ConcentrationMeasurementServer } from '@matter/main/behaviors/pm10-concentration-measurement';
 import { RadonConcentrationMeasurementServer } from '@matter/main/behaviors/radon-concentration-measurement';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@matter/main/behaviors/total-volatile-organic-compounds-concentration-measurement';
-function capitalizeFirstLetter(name) {
-    if (!name)
-        return name;
-    return name.charAt(0).toUpperCase() + name.slice(1);
-}
-function lowercaseFirstLetter(name) {
-    if (!name)
-        return name;
-    return name.charAt(0).toLowerCase() + name.slice(1);
-}
-function createUniqueId(param1, param2, param3, param4) {
-    const hash = createHash('md5');
-    hash.update(param1 + param2 + param3 + param4);
-    return hash.digest('hex');
-}
-function getBehaviourTypesFromClusterServerIds(clusterServerList) {
-    const behaviorTypes = [];
-    clusterServerList.forEach((clusterId) => {
-        behaviorTypes.push(getBehaviourTypeFromClusterServerId(clusterId));
-    });
-    return behaviorTypes;
-}
-function getBehaviourTypesFromClusterClientIds(clusterClientList) {
-    const behaviorTypes = [];
-    clusterClientList.forEach((clusterId) => {
-    });
-    return behaviorTypes;
-}
-function getBehaviourTypeFromClusterServerId(clusterId) {
-    if (clusterId === PowerSource.Cluster.id)
-        return PowerSourceServer.with(PowerSource.Feature.Wired);
-    if (clusterId === UserLabel.Cluster.id)
-        return UserLabelServer;
-    if (clusterId === FixedLabel.Cluster.id)
-        return FixedLabelServer;
-    if (clusterId === BasicInformation.Cluster.id)
-        return BasicInformationServer;
-    if (clusterId === BridgedDeviceBasicInformation.Cluster.id)
-        return BridgedDeviceBasicInformationServer;
-    if (clusterId === Identify.Cluster.id)
-        return MatterbridgeIdentifyServer;
-    if (clusterId === Groups.Cluster.id)
-        return GroupsServer;
-    if (clusterId === OnOff.Cluster.id)
-        return MatterbridgeOnOffServer.with('Lighting');
-    if (clusterId === LevelControl.Cluster.id)
-        return MatterbridgeLevelControlServer.with('OnOff', 'Lighting');
-    if (clusterId === ColorControl.Cluster.id)
-        return MatterbridgeColorControlServer;
-    if (clusterId === WindowCovering.Cluster.id)
-        return MatterbridgeWindowCoveringServer.with('Lift', 'PositionAwareLift');
-    if (clusterId === Thermostat.Cluster.id)
-        return MatterbridgeThermostatServer.with('AutoMode', 'Heating', 'Cooling');
-    if (clusterId === FanControl.Cluster.id)
-        return MatterbridgeFanControlServer;
-    if (clusterId === DoorLock.Cluster.id)
-        return MatterbridgeDoorLockServer;
-    if (clusterId === ModeSelect.Cluster.id)
-        return MatterbridgeModeSelectServer;
-    if (clusterId === ValveConfigurationAndControl.Cluster.id)
-        return MatterbridgeValveConfigurationAndControlServer.with('Level');
-    if (clusterId === PumpConfigurationAndControl.Cluster.id)
-        return PumpConfigurationAndControlServer.with('ConstantSpeed');
-    if (clusterId === SmokeCoAlarm.Cluster.id)
-        return MatterbridgeSmokeCoAlarmServer.with('SmokeAlarm', 'CoAlarm');
-    if (clusterId === Switch.Cluster.id)
-        return SwitchServer.with('MomentarySwitch', 'MomentarySwitchRelease', 'MomentarySwitchLongPress', 'MomentarySwitchMultiPress');
-    if (clusterId === BooleanState.Cluster.id)
-        return BooleanStateServer.enable({ events: { stateChange: true } });
-    if (clusterId === BooleanStateConfiguration.Cluster.id)
-        return MatterbridgeBooleanStateConfigurationServer;
-    if (clusterId === PowerTopology.Cluster.id)
-        return PowerTopologyServer.with('TreeTopology');
-    if (clusterId === ElectricalPowerMeasurement.Cluster.id)
-        return ElectricalPowerMeasurementServer.with('AlternatingCurrent');
-    if (clusterId === ElectricalEnergyMeasurement.Cluster.id)
-        return ElectricalEnergyMeasurementServer.with('ImportedEnergy', 'ExportedEnergy', 'CumulativeEnergy');
-    if (clusterId === TemperatureMeasurement.Cluster.id)
-        return TemperatureMeasurementServer;
-    if (clusterId === RelativeHumidityMeasurement.Cluster.id)
-        return RelativeHumidityMeasurementServer;
-    if (clusterId === PressureMeasurement.Cluster.id)
-        return PressureMeasurementServer;
-    if (clusterId === FlowMeasurement.Cluster.id)
-        return FlowMeasurementServer;
-    if (clusterId === IlluminanceMeasurement.Cluster.id)
-        return IlluminanceMeasurementServer;
-    if (clusterId === OccupancySensing.Cluster.id)
-        return OccupancySensingServer;
-    if (clusterId === AirQuality.Cluster.id)
-        return AirQualityServer.with('Fair', 'Moderate', 'VeryPoor', 'ExtremelyPoor');
-    if (clusterId === CarbonMonoxideConcentrationMeasurement.Cluster.id)
-        return CarbonMonoxideConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === CarbonDioxideConcentrationMeasurement.Cluster.id)
-        return CarbonDioxideConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === NitrogenDioxideConcentrationMeasurement.Cluster.id)
-        return NitrogenDioxideConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === OzoneConcentrationMeasurement.Cluster.id)
-        return OzoneConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === FormaldehydeConcentrationMeasurement.Cluster.id)
-        return FormaldehydeConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === Pm1ConcentrationMeasurement.Cluster.id)
-        return Pm1ConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === Pm25ConcentrationMeasurement.Cluster.id)
-        return Pm25ConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === Pm10ConcentrationMeasurement.Cluster.id)
-        return Pm10ConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === RadonConcentrationMeasurement.Cluster.id)
-        return RadonConcentrationMeasurementServer.with('NumericMeasurement');
-    if (clusterId === TotalVolatileOrganicCompoundsConcentrationMeasurement.Cluster.id)
-        return TotalVolatileOrganicCompoundsConcentrationMeasurementServer.with('NumericMeasurement');
-    return MatterbridgeIdentifyServer;
-}
-function getBehaviourTypeFromClusterClientId(clusterId) {
-}
-function getBehavior(endpoint, cluster) {
-    let behavior;
-    if (typeof cluster === 'string') {
-        behavior = endpoint.behaviors.supported[lowercaseFirstLetter(cluster)];
-    }
-    else if (typeof cluster === 'number') {
-        behavior = endpoint.behaviors.supported[lowercaseFirstLetter(getClusterNameById(cluster))];
-    }
-    else if (typeof cluster === 'object') {
-        behavior = endpoint.behaviors.supported[lowercaseFirstLetter(cluster.name)];
-    }
-    else if (typeof cluster === 'function') {
-        behavior = cluster;
-    }
-    return behavior;
-}
-function addRequiredClusterServers(endpoint) {
-    const requiredServerList = [];
-    endpoint.log.debug(`addRequiredClusterServers for ${CYAN}${endpoint.maybeId}${db}`);
-    endpoint.deviceTypes.values().forEach((deviceType) => {
-        endpoint.log.debug(`- for deviceType: ${zb}${'0x' + deviceType.code.toString(16).padStart(4, '0')}${db}-${zb}${deviceType.name}${db}`);
-        deviceType.requiredServerClusters.forEach((clusterId) => {
-            if (!requiredServerList.includes(clusterId) && !endpoint.hasClusterServer(clusterId)) {
-                requiredServerList.push(clusterId);
-                endpoint.log.debug(`- cluster: ${hk}${'0x' + clusterId.toString(16).padStart(4, '0')}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
-            }
-        });
-    });
-    addClusterServers(endpoint, requiredServerList);
-}
-function addOptionalClusterServers(endpoint) {
-    const optionalServerList = [];
-    endpoint.log.debug(`addOptionalClusterServers for ${CYAN}${endpoint.maybeId}${db}`);
-    endpoint.deviceTypes.values().forEach((deviceType) => {
-        endpoint.log.debug(`- for deviceType: ${zb}${'0x' + deviceType.code.toString(16).padStart(4, '0')}${db}-${zb}${deviceType.name}${db}`);
-        deviceType.optionalServerClusters.forEach((clusterId) => {
-            if (!optionalServerList.includes(clusterId) && !endpoint.hasClusterServer(clusterId)) {
-                optionalServerList.push(clusterId);
-                endpoint.log.debug(`- cluster: ${hk}${'0x' + clusterId.toString(16).padStart(4, '0')}${db}-${hk}${getClusterNameById(clusterId)}${db}`);
-            }
-        });
-    });
-    addClusterServers(endpoint, optionalServerList);
-}
-function addClusterServers(endpoint, serverList) {
-    if (serverList.includes(PowerSource.Cluster.id))
-        endpoint.createDefaultPowerSourceWiredClusterServer();
-    if (serverList.includes(Identify.Cluster.id))
-        endpoint.createDefaultIdentifyClusterServer();
-    if (serverList.includes(Groups.Cluster.id))
-        endpoint.createDefaultGroupsClusterServer();
-    if (serverList.includes(OnOff.Cluster.id))
-        endpoint.createDefaultOnOffClusterServer();
-    if (serverList.includes(LevelControl.Cluster.id))
-        endpoint.createDefaultLevelControlClusterServer();
-    if (serverList.includes(ColorControl.Cluster.id))
-        endpoint.createDefaultColorControlClusterServer();
-    if (serverList.includes(WindowCovering.Cluster.id))
-        endpoint.createDefaultWindowCoveringClusterServer();
-    if (serverList.includes(Thermostat.Cluster.id))
-        endpoint.createDefaultThermostatClusterServer();
-    if (serverList.includes(FanControl.Cluster.id))
-        endpoint.createDefaultFanControlClusterServer();
-    if (serverList.includes(DoorLock.Cluster.id))
-        endpoint.createDefaultDoorLockClusterServer();
-    if (serverList.includes(ValveConfigurationAndControl.Cluster.id))
-        endpoint.createDefaultValveConfigurationAndControlClusterServer();
-    if (serverList.includes(PumpConfigurationAndControl.Cluster.id))
-        endpoint.createDefaultPumpConfigurationAndControlClusterServer();
-    if (serverList.includes(SmokeCoAlarm.Cluster.id))
-        endpoint.createDefaultSmokeCOAlarmClusterServer();
-    if (serverList.includes(Switch.Cluster.id))
-        endpoint.createDefaultSwitchClusterServer();
-    if (serverList.includes(BooleanState.Cluster.id))
-        endpoint.createDefaultBooleanStateClusterServer();
-    if (serverList.includes(BooleanStateConfiguration.Cluster.id))
-        endpoint.createDefaultBooleanStateConfigurationClusterServer();
-    if (serverList.includes(PowerTopology.Cluster.id))
-        endpoint.createDefaultPowerTopologyClusterServer();
-    if (serverList.includes(ElectricalPowerMeasurement.Cluster.id))
-        endpoint.createDefaultElectricalPowerMeasurementClusterServer();
-    if (serverList.includes(ElectricalEnergyMeasurement.Cluster.id))
-        endpoint.createDefaultElectricalEnergyMeasurementClusterServer();
-    if (serverList.includes(TemperatureMeasurement.Cluster.id))
-        endpoint.createDefaultTemperatureMeasurementClusterServer();
-    if (serverList.includes(RelativeHumidityMeasurement.Cluster.id))
-        endpoint.createDefaultRelativeHumidityMeasurementClusterServer();
-    if (serverList.includes(PressureMeasurement.Cluster.id))
-        endpoint.createDefaultPressureMeasurementClusterServer();
-    if (serverList.includes(FlowMeasurement.Cluster.id))
-        endpoint.createDefaultFlowMeasurementClusterServer();
-    if (serverList.includes(IlluminanceMeasurement.Cluster.id))
-        endpoint.createDefaultIlluminanceMeasurementClusterServer();
-    if (serverList.includes(OccupancySensing.Cluster.id))
-        endpoint.createDefaultOccupancySensingClusterServer();
-    if (serverList.includes(AirQuality.Cluster.id))
-        endpoint.createDefaultAirQualityClusterServer();
-    if (serverList.includes(CarbonMonoxideConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultCarbonMonoxideConcentrationMeasurementClusterServer();
-    if (serverList.includes(CarbonDioxideConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultCarbonDioxideConcentrationMeasurementClusterServer();
-    if (serverList.includes(NitrogenDioxideConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultNitrogenDioxideConcentrationMeasurementClusterServer();
-    if (serverList.includes(OzoneConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultOzoneConcentrationMeasurementClusterServer();
-    if (serverList.includes(FormaldehydeConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultFormaldehydeConcentrationMeasurementClusterServer();
-    if (serverList.includes(Pm1ConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultPm1ConcentrationMeasurementClusterServer();
-    if (serverList.includes(Pm25ConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultPm25ConcentrationMeasurementClusterServer();
-    if (serverList.includes(Pm10ConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultPm10ConcentrationMeasurementClusterServer();
-    if (serverList.includes(RadonConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultRadonConcentrationMeasurementClusterServer();
-    if (serverList.includes(TotalVolatileOrganicCompoundsConcentrationMeasurement.Cluster.id))
-        endpoint.createDefaultTvocMeasurementClusterServer();
-}
-export function optionsFor(type, options) {
-    return options;
-}
 export class MatterbridgeEndpoint extends Endpoint {
     static bridgeMode = '';
     static logLevel = "info";
@@ -337,7 +76,6 @@ export class MatterbridgeEndpoint extends Endpoint {
     deviceType;
     uniqueStorageKey = undefined;
     tagList = undefined;
-    subType = '';
     deviceTypes = new Map();
     commandHandler = new NamedHandler();
     constructor(definition, options = {}, debug = false) {
@@ -412,7 +150,8 @@ export class MatterbridgeEndpoint extends Endpoint {
         if (!behavior || !this.behaviors.supported[behavior.id])
             return false;
         const options = this.behaviors.optionsFor(behavior);
-        return lowercaseFirstLetter(attribute) in options;
+        const defaults = this.behaviors.defaultsFor(behavior);
+        return lowercaseFirstLetter(attribute) in options || lowercaseFirstLetter(attribute) in defaults;
     }
     getClusterServerOptions(cluster) {
         const behavior = getBehavior(this, cluster);
@@ -420,50 +159,14 @@ export class MatterbridgeEndpoint extends Endpoint {
             return undefined;
         return this.behaviors.optionsFor(behavior);
     }
-    getAttribute(clusterId, attribute, log) {
-        const clusterName = lowercaseFirstLetter(getClusterNameById(clusterId));
-        if (this.construction.status !== Lifecycle.Status.Active) {
-            this.log.error(`getAttribute ${hk}${clusterName}.${attribute}${er} error: Endpoint ${or}${this.maybeId}${er}:${or}${this.maybeNumber}${er} is in the ${BLUE}${this.construction.status}${er} state`);
-            return undefined;
-        }
-        const state = this.state;
-        if (!(clusterName in state)) {
-            this.log.error(`getAttribute error: Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} not found on endpoint ${or}${this.id}${er}:${or}${this.number}${er}`);
-            return undefined;
-        }
-        attribute = lowercaseFirstLetter(attribute);
-        if (!(attribute in state[clusterName])) {
-            this.log.error(`getAttribute error: Attribute ${hk}${attribute}${er} not found on Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} on endpoint ${or}${this.id}${er}:${or}${this.number}${er}`);
-            return undefined;
-        }
-        const value = state[clusterName][attribute];
-        log?.info(`${db}Get endpoint ${or}${this.id}${db}:${or}${this.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db} value ${YELLOW}${value !== null && typeof value === 'object' ? debugStringify(value) : value}${db}`);
-        return value;
+    getAttribute(cluster, attribute, log) {
+        return getAttribute(this, cluster, attribute, log);
     }
     async setAttribute(clusterId, attribute, value, log) {
-        const clusterName = lowercaseFirstLetter(getClusterNameById(clusterId));
-        if (this.construction.status !== Lifecycle.Status.Active) {
-            this.log.error(`setAttribute ${hk}${clusterName}.${attribute}${er} error: Endpoint ${or}${this.maybeId}${er}:${or}${this.maybeNumber}${er} is in the ${BLUE}${this.construction.status}${er} state`);
-            return false;
-        }
-        const state = this.state;
-        if (!(clusterName in state)) {
-            this.log.error(`setAttribute ${hk}${attribute}${er} error: Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} not found on endpoint ${or}${this.id}${er}:${or}${this.number}${er}`);
-            return false;
-        }
-        attribute = lowercaseFirstLetter(attribute);
-        if (!(attribute in state[clusterName])) {
-            this.log.error(`setAttribute error: Attribute ${hk}${attribute}${er} not found on Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} on endpoint ${or}${this.id}${er}:${or}${this.number}${er}`);
-            return false;
-        }
-        let oldValue = state[clusterName][attribute];
-        if (typeof oldValue === 'object')
-            oldValue = deepCopy(oldValue);
-        await this.setStateOf(this.behaviors.supported[clusterName], { [attribute]: value });
-        log?.info(`${db}Set endpoint ${or}${this.id}${db}:${or}${this.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db} ` +
-            `from ${YELLOW}${oldValue !== null && typeof oldValue === 'object' ? debugStringify(oldValue) : oldValue}${db} ` +
-            `to ${YELLOW}${value !== null && typeof value === 'object' ? debugStringify(value) : value}${db}`);
-        return true;
+        return await setAttribute(this, clusterId, attribute, value, log);
+    }
+    async updateAttribute(cluster, attribute, value, log) {
+        return await updateAttribute(this, cluster, attribute, value, log);
     }
     async subscribeAttribute(clusterId, attribute, listener, log) {
         const clusterName = lowercaseFirstLetter(getClusterNameById(clusterId));
@@ -484,52 +187,30 @@ export class MatterbridgeEndpoint extends Endpoint {
         log?.info(`${db}Subscribed endpoint ${or}${this.id}${db}:${or}${this.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db}`);
         return true;
     }
-    async triggerEvent(clusterId, event, payload, log, endpoint) {
-        if (!endpoint)
-            endpoint = this;
+    async triggerEvent(clusterId, event, payload, log) {
         const clusterName = lowercaseFirstLetter(getClusterNameById(clusterId));
-        if (endpoint.construction.status !== Lifecycle.Status.Active) {
-            this.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`);
+        if (this.construction.status !== Lifecycle.Status.Active) {
+            this.log.error(`triggerEvent ${hk}${clusterName}.${event}${er} error: Endpoint ${or}${this.maybeId}${er}:${or}${this.maybeNumber}${er} is in the ${BLUE}${this.construction.status}${er} state`);
             return false;
         }
-        const events = endpoint.events;
+        const events = this.events;
         if (!(clusterName in events) || !(event in events[clusterName])) {
-            this.log.error(`triggerEvent ${hk}${event}${er} error: Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} not found on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
+            this.log.error(`triggerEvent ${hk}${event}${er} error: Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} not found on endpoint ${or}${this.id}${er}:${or}${this.number}${er}`);
             return false;
         }
-        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} `);
+        await this.act((agent) => agent[clusterName].events[event].emit(payload, agent.context));
+        log?.info(`${db}Trigger event ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${event}${db} with ${debugStringify(payload)}${db} on endpoint ${or}${this.id}${db}:${or}${this.number}${db} `);
         return true;
     }
     addClusterServers(serverList) {
         addClusterServers(this, serverList);
     }
     async addFixedLabel(label, value) {
-        if (!this.hasClusterServer(FixedLabel.Cluster.id)) {
-            this.log.debug(`addFixedLabel: add cluster ${hk}FixedLabel${db}:${hk}fixedLabel${db} with label ${CYAN}${label}${db} value ${CYAN}${value}${db}`);
-            this.behaviors.require(FixedLabelServer, {
-                labelList: [{ label, value }],
-            });
-            return this;
-        }
-        this.log.debug(`addFixedLabel: add label ${CYAN}${label}${db} value ${CYAN}${value}${db}`);
-        const labelList = (this.getAttribute(FixedLabel.Cluster.id, 'labelList', this.log) ?? []).filter((entryLabel) => entryLabel.label !== label);
-        labelList.push({ label, value });
-        await this.setAttribute(FixedLabel.Cluster.id, 'labelList', labelList, this.log);
+        await addFixedLabel(this, label, value);
         return this;
     }
     async addUserLabel(label, value) {
-        if (!this.hasClusterServer(UserLabel.Cluster.id)) {
-            this.log.debug(`addUserLabel: add cluster ${hk}UserLabel${db}:${hk}userLabel${db} with label ${CYAN}${label}${db} value ${CYAN}${value}${db}`);
-            this.behaviors.require(UserLabelServer, {
-                labelList: [{ label, value }],
-            });
-            return this;
-        }
-        this.log.debug(`addUserLabel: add label ${CYAN}${label}${db} value ${CYAN}${value}${db}`);
-        const labelList = (this.getAttribute(UserLabel.Cluster.id, 'labelList', this.log) ?? []).filter((entryLabel) => entryLabel.label !== label);
-        labelList.push({ label, value });
-        await this.setAttribute(UserLabel.Cluster.id, 'labelList', labelList, this.log);
+        await addUserLabel(this, label, value);
         return this;
     }
     addCommandHandler(command, handler) {
@@ -547,6 +228,27 @@ export class MatterbridgeEndpoint extends Endpoint {
         addOptionalClusterServers(this);
         return this;
     }
+    getAllClusterServers() {
+        return Object.values(this.behaviors.supported);
+    }
+    getAllClusterServerNames() {
+        return Object.keys(this.behaviors.supported);
+    }
+    forEachAttribute(callback) {
+        for (const [clusterName, clusterAttributes] of Object.entries(this.state)) {
+            for (const [attributeName, attributeValue] of Object.entries(clusterAttributes)) {
+                const clusterId = getClusterId(this, clusterName);
+                if (clusterId === undefined) {
+                    continue;
+                }
+                const attributeId = getAttributeId(this, clusterName, attributeName);
+                if (attributeId === undefined) {
+                    continue;
+                }
+                callback(clusterName, clusterId, attributeName, attributeId, attributeValue);
+            }
+        }
+    }
     addChildDeviceType(endpointName, definition, options = {}, debug = false) {
         this.log.debug(`addChildDeviceType: ${CYAN}${endpointName}${db}`);
         let alreadyAdded = false;
@@ -937,7 +639,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             await this.setAttribute(ColorControl.Cluster.id, 'colorMode', colorMode, this.log);
             await this.setAttribute(ColorControl.Cluster.id, 'enhancedColorMode', colorMode, this.log);
         }
-        return this;
     }
     createDefaultWindowCoveringClusterServer(positionPercent100ths) {
         this.behaviors.require(MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift), {
@@ -961,7 +662,7 @@ export class MatterbridgeEndpoint extends Endpoint {
     }
     async setWindowCoveringTargetAsCurrentAndStopped() {
         const position = this.getAttribute(WindowCovering.Cluster.id, 'currentPositionLiftPercent100ths', this.log);
-        if (position !== null) {
+        if (isValidNumber(position, 0, 10000)) {
             await this.setAttribute(WindowCovering.Cluster.id, 'targetPositionLiftPercent100ths', position, this.log);
             await this.setAttribute(WindowCovering.Cluster.id, 'operationalStatus', {
                 global: WindowCovering.MovementStatus.Stopped,
@@ -991,8 +692,10 @@ export class MatterbridgeEndpoint extends Endpoint {
     }
     getWindowCoveringStatus() {
         const status = this.getAttribute(WindowCovering.Cluster.id, 'operationalStatus', this.log);
-        this.log.debug(`Get WindowCovering operationalStatus: ${status.global}`);
-        return status.global;
+        if (isValidObject(status, 3) && 'global' in status && typeof status.global === 'number') {
+            this.log.debug(`Get WindowCovering operationalStatus: ${status.global}`);
+            return status.global;
+        }
     }
     async setWindowCoveringTargetAndCurrentPosition(position) {
         await this.setAttribute(WindowCovering.Cluster.id, 'currentPositionLiftPercent100ths', position, this.log);
@@ -1121,7 +824,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createDefaultSwitchClusterServer() {
-        this.behaviors.require(SwitchServer.with(Switch.Feature.MomentarySwitch, Switch.Feature.MomentarySwitchRelease, Switch.Feature.MomentarySwitchLongPress, Switch.Feature.MomentarySwitchMultiPress).enable({
+        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 },
         }), {
             numberOfPositions: 2,
@@ -1280,76 +983,28 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    getDefaultTemperatureMeasurementClusterServer(measuredValue = 0) {
-        return optionsFor(TemperatureMeasurementServer, {
-            measuredValue,
-            minMeasuredValue: null,
-            maxMeasuredValue: null,
-            tolerance: 0,
-        });
-    }
     createDefaultTemperatureMeasurementClusterServer(measuredValue = 0) {
-        this.behaviors.require(TemperatureMeasurementServer, this.getDefaultTemperatureMeasurementClusterServer(measuredValue));
+        this.behaviors.require(TemperatureMeasurementServer, getDefaultTemperatureMeasurementClusterServer(measuredValue));
         return this;
     }
-    getDefaultRelativeHumidityMeasurementClusterServer(measuredValue = 0) {
-        return optionsFor(RelativeHumidityMeasurementServer, {
-            measuredValue,
-            minMeasuredValue: null,
-            maxMeasuredValue: null,
-            tolerance: 0,
-        });
-    }
     createDefaultRelativeHumidityMeasurementClusterServer(measuredValue = 0) {
-        this.behaviors.require(RelativeHumidityMeasurementServer, this.getDefaultRelativeHumidityMeasurementClusterServer(measuredValue));
+        this.behaviors.require(RelativeHumidityMeasurementServer, getDefaultRelativeHumidityMeasurementClusterServer(measuredValue));
         return this;
     }
-    getDefaultPressureMeasurementClusterServer(measuredValue = 1000) {
-        return optionsFor(PressureMeasurementServer, {
-            measuredValue,
-            minMeasuredValue: null,
-            maxMeasuredValue: null,
-            tolerance: 0,
-        });
-    }
     createDefaultPressureMeasurementClusterServer(measuredValue = 1000) {
-        this.behaviors.require(PressureMeasurementServer, this.getDefaultPressureMeasurementClusterServer(measuredValue));
+        this.behaviors.require(PressureMeasurementServer, getDefaultPressureMeasurementClusterServer(measuredValue));
         return this;
     }
-    getDefaultIlluminanceMeasurementClusterServer(measuredValue = 0) {
-        return optionsFor(IlluminanceMeasurementServer, {
-            measuredValue,
-            minMeasuredValue: null,
-            maxMeasuredValue: null,
-            tolerance: 0,
-        });
-    }
     createDefaultIlluminanceMeasurementClusterServer(measuredValue = 0) {
-        this.behaviors.require(IlluminanceMeasurementServer, this.getDefaultIlluminanceMeasurementClusterServer(measuredValue));
+        this.behaviors.require(IlluminanceMeasurementServer, getDefaultIlluminanceMeasurementClusterServer(measuredValue));
         return this;
     }
-    getDefaultFlowMeasurementClusterServer(measuredValue = 0) {
-        return optionsFor(FlowMeasurementServer, {
-            measuredValue,
-            minMeasuredValue: null,
-            maxMeasuredValue: null,
-            tolerance: 0,
-        });
-    }
     createDefaultFlowMeasurementClusterServer(measuredValue = 0) {
-        this.behaviors.require(FlowMeasurementServer, this.getDefaultFlowMeasurementClusterServer(measuredValue));
+        this.behaviors.require(FlowMeasurementServer, getDefaultFlowMeasurementClusterServer(measuredValue));
         return this;
     }
-    getDefaultOccupancySensingClusterServer(occupied = false) {
-        return optionsFor(OccupancySensingServer, {
-            occupancy: { occupied },
-            occupancySensorType: OccupancySensing.OccupancySensorType.Pir,
-            occupancySensorTypeBitmap: { pir: true, ultrasonic: false, physicalContact: false },
-            pirOccupiedToUnoccupiedDelay: 30,
-        });
-    }
     createDefaultOccupancySensingClusterServer(occupied = false) {
-        this.behaviors.require(OccupancySensingServer, this.getDefaultOccupancySensingClusterServer(occupied));
+        this.behaviors.require(OccupancySensingServer, getDefaultOccupancySensingClusterServer(occupied));
         return this;
     }
     createDefaultAirQualityClusterServer(airQuality = AirQuality.AirQualityEnum.Unknown) {