matterbridge 2.0.0 → 2.1.0-dev.10

package/dist/matterbridgeEndpointHelpers.js

@@ -0,0 +1,513 @@
+import { createHash } from 'crypto';
+import { BLUE, CYAN, db, debugStringify, er, hk, or, YELLOW, zb } from './logger/export.js';
+import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, } from './matterbridgeBehaviors.js';
+import { Lifecycle } from '@matter/main';
+import { getClusterNameById } from '@matter/main/types';
+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';
+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 { 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 { PumpConfigurationAndControlServer } from '@matter/main/behaviors/pump-configuration-and-control';
+import { SwitchServer } from '@matter/main/behaviors/switch';
+import { BooleanStateServer } from '@matter/main/behaviors/boolean-state';
+import { PowerTopologyServer } from '@matter/main/behaviors/power-topology';
+import { ElectricalPowerMeasurementServer } from '@matter/main/behaviors/electrical-power-measurement';
+import { ElectricalEnergyMeasurementServer } from '@matter/main/behaviors/electrical-energy-measurement';
+import { TemperatureMeasurementServer } from '@matter/main/behaviors/temperature-measurement';
+import { RelativeHumidityMeasurementServer } from '@matter/main/behaviors/relative-humidity-measurement';
+import { PressureMeasurementServer } from '@matter/main/behaviors/pressure-measurement';
+import { FlowMeasurementServer } from '@matter/main/behaviors/flow-measurement';
+import { IlluminanceMeasurementServer } from '@matter/main/behaviors/illuminance-measurement';
+import { OccupancySensingServer } from '@matter/main/behaviors/occupancy-sensing';
+import { AirQualityServer } from '@matter/main/behaviors/air-quality';
+import { CarbonMonoxideConcentrationMeasurementServer } from '@matter/main/behaviors/carbon-monoxide-concentration-measurement';
+import { CarbonDioxideConcentrationMeasurementServer } from '@matter/main/behaviors/carbon-dioxide-concentration-measurement';
+import { NitrogenDioxideConcentrationMeasurementServer } from '@matter/main/behaviors/nitrogen-dioxide-concentration-measurement';
+import { OzoneConcentrationMeasurementServer } from '@matter/main/behaviors/ozone-concentration-measurement';
+import { FormaldehydeConcentrationMeasurementServer } from '@matter/main/behaviors/formaldehyde-concentration-measurement';
+import { Pm1ConcentrationMeasurementServer } from '@matter/main/behaviors/pm1-concentration-measurement';
+import { Pm25ConcentrationMeasurementServer } from '@matter/main/behaviors/pm25-concentration-measurement';
+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';
+import { deepCopy, deepEqual, isValidArray } from './utils/utils.js';
+export function capitalizeFirstLetter(name) {
+    if (!name)
+        return name;
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+export function lowercaseFirstLetter(name) {
+    if (!name)
+        return name;
+    return name.charAt(0).toLowerCase() + name.slice(1);
+}
+export function createUniqueId(param1, param2, param3, param4) {
+    const hash = createHash('md5');
+    hash.update(param1 + param2 + param3 + param4);
+    return hash.digest('hex');
+}
+export function getBehaviourTypesFromClusterServerIds(clusterServerList) {
+    const behaviorTypes = [];
+    clusterServerList.forEach((clusterId) => {
+        behaviorTypes.push(getBehaviourTypeFromClusterServerId(clusterId));
+    });
+    return behaviorTypes;
+}
+export function getBehaviourTypesFromClusterClientIds(clusterClientList) {
+    const behaviorTypes = [];
+    clusterClientList.forEach((clusterId) => {
+    });
+    return behaviorTypes;
+}
+export 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;
+}
+export function getBehaviourTypeFromClusterClientId(clusterId) {
+}
+export 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;
+}
+export function addRequiredClusterServers(endpoint) {
+    const requiredServerList = [];
+    endpoint.log.debug(`addRequiredClusterServers for ${CYAN}${endpoint.maybeId}${db}`);
+    Array.from(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);
+}
+export function addOptionalClusterServers(endpoint) {
+    const optionalServerList = [];
+    endpoint.log.debug(`addOptionalClusterServers for ${CYAN}${endpoint.maybeId}${db}`);
+    Array.from(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);
+}
+export 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 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}`);
+        endpoint.behaviors.require(FixedLabelServer, {
+            labelList: [{ label, value }],
+        });
+        return;
+    }
+    endpoint.log.debug(`addFixedLabel: add label ${CYAN}${label}${db} value ${CYAN}${value}${db}`);
+    let labelList = endpoint.getAttribute(FixedLabel.Cluster.id, 'labelList', endpoint.log);
+    if (isValidArray(labelList)) {
+        labelList = labelList.filter((entry) => entry.label !== label);
+        labelList.push({ label, value });
+        await endpoint.setAttribute(FixedLabel.Cluster.id, 'labelList', labelList, endpoint.log);
+    }
+}
+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}`);
+        endpoint.behaviors.require(UserLabelServer, {
+            labelList: [{ label, value }],
+        });
+        return;
+    }
+    endpoint.log.debug(`addUserLabel: add label ${CYAN}${label}${db} value ${CYAN}${value}${db}`);
+    let labelList = endpoint.getAttribute(UserLabel.Cluster.id, 'labelList', endpoint.log);
+    if (isValidArray(labelList)) {
+        labelList = labelList.filter((entry) => entry.label !== label);
+        labelList.push({ label, value });
+        await endpoint.setAttribute(UserLabel.Cluster.id, 'labelList', labelList, endpoint.log);
+    }
+}
+export function optionsFor(type, options) {
+    return options;
+}
+export function getClusterId(endpoint, cluster) {
+    return endpoint.behaviors.supported[lowercaseFirstLetter(cluster)]?.schema?.id;
+}
+export function getAttributeId(endpoint, cluster, attribute) {
+    if (attribute === 'attributeList')
+        return 0xfffb;
+    else if (attribute === 'featureMap')
+        return 0xfffc;
+    else if (attribute === 'eventList')
+        return 0xfffa;
+    else if (attribute === 'generatedCommandList')
+        return 0xfff8;
+    else if (attribute === 'acceptedCommandList')
+        return 0xfff9;
+    else if (attribute === 'clusterRevision')
+        return 0xfffd;
+    else {
+        if (endpoint.behaviors.supported[lowercaseFirstLetter(cluster)]?.schema?.type === 'ConcentrationMeasurement') {
+            if (attribute === 'measuredValue')
+                return 0x0;
+            else if (attribute === 'minMeasuredValue')
+                return 0x1;
+            else if (attribute === 'maxMeasuredValue')
+                return 0x2;
+            else if (attribute === 'peakMeasuredValue')
+                return 0x3;
+            else if (attribute === 'peakMeasuredValueWindow')
+                return 0x4;
+            else if (attribute === 'averageMeasuredValue')
+                return 0x5;
+            else if (attribute === 'averageMeasuredValueWindow')
+                return 0x6;
+            else if (attribute === 'uncertainty')
+                return 0x7;
+            else if (attribute === 'measurementUnit')
+                return 0x8;
+            else if (attribute === 'measurementMedium')
+                return 0x9;
+            else if (attribute === 'levelValue')
+                return 0xa;
+        }
+        return endpoint.behaviors.supported[lowercaseFirstLetter(cluster)]?.schema?.children?.find((child) => child.name === capitalizeFirstLetter(attribute))?.id;
+    }
+}
+export function getAttribute(endpoint, cluster, attribute, log) {
+    const clusterName = getBehavior(endpoint, cluster)?.id;
+    if (!clusterName) {
+        endpoint.log.error(`getAttribute ${hk}${attribute}${er} error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+        return undefined;
+    }
+    if (endpoint.construction.status !== Lifecycle.Status.Active) {
+        endpoint.log.error(`getAttribute ${hk}${clusterName}.${attribute}${er} error: Endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er} is in the ${BLUE}${endpoint.construction.status}${er} state`);
+        return undefined;
+    }
+    const state = endpoint.state;
+    attribute = lowercaseFirstLetter(attribute);
+    if (!(attribute in state[clusterName])) {
+        endpoint.log.error(`getAttribute error: Attribute ${hk}${attribute}${er} not found on Cluster ${'0x' + getClusterId(endpoint, clusterName)?.toString(16).padStart(4, '0')}:${clusterName} on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
+        return undefined;
+    }
+    let value = state[clusterName][attribute];
+    if (typeof value === 'object')
+        value = deepCopy(value);
+    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;
+}
+export async function setAttribute(endpoint, cluster, attribute, value, log) {
+    const clusterName = getBehavior(endpoint, cluster)?.id;
+    if (!clusterName) {
+        endpoint.log.error(`setAttribute ${hk}${attribute}${er} error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+        return false;
+    }
+    if (endpoint.construction.status !== Lifecycle.Status.Active) {
+        endpoint.log.error(`setAttribute ${hk}${clusterName}.${attribute}${er} error: Endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er} is in the ${BLUE}${endpoint.construction.status}${er} state`);
+        return false;
+    }
+    const state = endpoint.state;
+    attribute = lowercaseFirstLetter(attribute);
+    if (!(attribute in state[clusterName])) {
+        endpoint.log.error(`setAttribute error: Attribute ${hk}${attribute}${er} not found on cluster ${'0x' + getClusterId(endpoint, clusterName)?.toString(16).padStart(4, '0')}:${clusterName} on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
+        return false;
+    }
+    let oldValue = state[clusterName][attribute];
+    if (typeof oldValue === 'object')
+        oldValue = deepCopy(oldValue);
+    await endpoint.setStateOf(endpoint.behaviors.supported[clusterName], { [attribute]: value });
+    log?.info(`${db}Set endpoint ${or}${endpoint.id}${db}:${or}${endpoint.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;
+}
+export async function updateAttribute(endpoint, cluster, attribute, value, log) {
+    const clusterName = getBehavior(endpoint, cluster)?.id;
+    if (!clusterName) {
+        endpoint.log.error(`updateAttribute ${hk}${attribute}${er} error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+        return false;
+    }
+    if (endpoint.construction.status !== Lifecycle.Status.Active) {
+        endpoint.log.error(`updateAttribute ${hk}${clusterName}.${attribute}${er} error: Endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er} is in the ${BLUE}${endpoint.construction.status}${er} state`);
+        return false;
+    }
+    const state = endpoint.state;
+    attribute = lowercaseFirstLetter(attribute);
+    if (!(attribute in state[clusterName])) {
+        endpoint.log.error(`updateAttribute error: Attribute ${hk}${attribute}${er} not found on cluster ${'0x' + getClusterId(endpoint, clusterName)?.toString(16).padStart(4, '0')}:${clusterName} on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
+        return false;
+    }
+    let oldValue = state[clusterName][attribute];
+    if (typeof oldValue === 'object') {
+        if (deepEqual(oldValue, value))
+            return false;
+        oldValue = deepCopy(oldValue);
+    }
+    else if (oldValue === value)
+        return false;
+    await endpoint.setStateOf(endpoint.behaviors.supported[clusterName], { [attribute]: value });
+    log?.info(`${db}Update endpoint ${or}${endpoint.id}${db}:${or}${endpoint.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;
+}
+export function getDefaultTemperatureMeasurementClusterServer(measuredValue = 0) {
+    return optionsFor(TemperatureMeasurementServer, {
+        measuredValue,
+        minMeasuredValue: null,
+        maxMeasuredValue: null,
+        tolerance: 0,
+    });
+}
+export function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue = 0) {
+    return optionsFor(RelativeHumidityMeasurementServer, {
+        measuredValue,
+        minMeasuredValue: null,
+        maxMeasuredValue: null,
+        tolerance: 0,
+    });
+}
+export function getDefaultPressureMeasurementClusterServer(measuredValue = 1000) {
+    return optionsFor(PressureMeasurementServer, {
+        measuredValue,
+        minMeasuredValue: null,
+        maxMeasuredValue: null,
+        tolerance: 0,
+    });
+}
+export function getDefaultIlluminanceMeasurementClusterServer(measuredValue = 0) {
+    return optionsFor(IlluminanceMeasurementServer, {
+        measuredValue,
+        minMeasuredValue: null,
+        maxMeasuredValue: null,
+        tolerance: 0,
+    });
+}
+export function getDefaultFlowMeasurementClusterServer(measuredValue = 0) {
+    return optionsFor(FlowMeasurementServer, {
+        measuredValue,
+        minMeasuredValue: null,
+        maxMeasuredValue: null,
+        tolerance: 0,
+    });
+}
+export function getDefaultOccupancySensingClusterServer(occupied = false) {
+    return optionsFor(OccupancySensingServer, {
+        occupancy: { occupied },
+        occupancySensorType: OccupancySensing.OccupancySensorType.Pir,
+        occupancySensorTypeBitmap: { pir: true, ultrasonic: false, physicalContact: false },
+        pirOccupiedToUnoccupiedDelay: 30,
+    });
+}