matterbridge 3.0.5-dev-20250607-86b467e → 3.0.5-dev-20250607-ef2d8e1

package/CHANGELOG.md

@@ -8,11 +8,12 @@ If you like this project and find it useful, please consider giving it a star on
   <img src="bmc-button.svg" alt="Buy me a coffee" width="120">
 </a>
 
-## [3.0.5] - 2025-05-??
+## [3.0.5] - 2025-06-07
 
 ### Added
 
 - [cli]: Added takeHeapSnapshot() and triggerGarbageCollection().
+- [LaundryWasher]: Added Evse class and Jest test. Thanks Ludovic BOUÉ.
 - [LaundryWasher]: Added LaundryWasher class and Jest test.
 - [WaterHeater]: Added WaterHeater class and Jest test. Thanks Ludovic BOUÉ.
 - [nginx]: Added new example configurations for [nginx](README-NGINX.md).

package/dist/evse.js

@@ -0,0 +1,85 @@
+import { EnergyEvseServer } from '@matter/main/behaviors/energy-evse';
+import { EnergyEvseModeServer } from '@matter/main/behaviors/energy-evse-mode';
+import { EnergyEvse, EnergyEvseMode } from '@matter/main/clusters';
+import { ModeBase } from '@matter/main/clusters/mode-base';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { MatterbridgeServer } from './matterbridgeBehaviors.js';
+import { deviceEnergyManagement, electricalSensor, evse, powerSource } from './matterbridgeDeviceTypes.js';
+export class Evse extends MatterbridgeEndpoint {
+    constructor(name, serial, state, supplyState, faultState) {
+        super([evse, powerSource, electricalSensor, deviceEnergyManagement], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        this.createDefaultIdentifyClusterServer()
+            .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge EVSE')
+            .createDefaultPowerSourceWiredClusterServer()
+            .createDefaultPowerTopologyClusterServer()
+            .createDefaultElectricalPowerMeasurementClusterServer()
+            .createDefaultElectricalEnergyMeasurementClusterServer()
+            .createDefaultDeviceEnergyManagementCluster()
+            .createDefaultEnergyEvseClusterServer(state, supplyState, faultState)
+            .createDefaultEnergyEvseModeClusterServer()
+            .addRequiredClusterServers();
+    }
+    createDefaultEnergyEvseClusterServer(state, supplyState, faultState) {
+        this.behaviors.require(MatterbridgeEnergyEvseServer, {
+            state: state ?? EnergyEvse.State.NotPluggedIn,
+            supplyState: supplyState ?? EnergyEvse.SupplyState.Disabled,
+            faultState: faultState ?? EnergyEvse.FaultState.NoError,
+            chargingEnabledUntil: 0,
+            circuitCapacity: 0,
+            minimumChargeCurrent: 6000,
+            maximumChargeCurrent: 0,
+            sessionId: null,
+            sessionDuration: 0,
+            sessionEnergyCharged: 0,
+        });
+        return this;
+    }
+    createDefaultEnergyEvseModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MatterbridgeEnergyEvseModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'Auto', mode: 1, modeTags: [{ value: EnergyEvseMode.ModeTag.Auto }] },
+                { label: 'Quick', mode: 2, modeTags: [{ value: EnergyEvseMode.ModeTag.Quick }] },
+                { label: 'Quiet', mode: 3, modeTags: [{ value: EnergyEvseMode.ModeTag.Quiet }] },
+                { label: 'LowNoise', mode: 4, modeTags: [{ value: EnergyEvseMode.ModeTag.LowNoise }] },
+                { label: 'LowEnergy', mode: 5, modeTags: [{ value: EnergyEvseMode.ModeTag.LowEnergy }] },
+                { label: 'Vacation', mode: 6, modeTags: [{ value: EnergyEvseMode.ModeTag.Vacation }] },
+                { label: 'Min', mode: 7, modeTags: [{ value: EnergyEvseMode.ModeTag.Min }] },
+                { label: 'Max', mode: 8, modeTags: [{ value: EnergyEvseMode.ModeTag.Max }] },
+                { label: 'Night', mode: 9, modeTags: [{ value: EnergyEvseMode.ModeTag.Night }] },
+                { label: 'Day', mode: 10, modeTags: [{ value: EnergyEvseMode.ModeTag.Day }] },
+                { label: 'Manual', mode: 11, modeTags: [{ value: EnergyEvseMode.ModeTag.Manual }] },
+                { label: 'TimeOfUse', mode: 12, modeTags: [{ value: EnergyEvseMode.ModeTag.TimeOfUse }] },
+                { label: 'SolarCharging', mode: 13, modeTags: [{ value: EnergyEvseMode.ModeTag.SolarCharging }] },
+                { label: 'V2X', mode: 14, modeTags: [{ value: EnergyEvseMode.ModeTag.V2X }] },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
+}
+export class MatterbridgeEnergyEvseServer extends EnergyEvseServer {
+    disable() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.disable();
+        device.log.info(`MatterbridgeEnergyEvseServer disable called`);
+    }
+    enableCharging() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.enableCharging();
+        device.log.info(`MatterbridgeEnergyEvseServer enableCharging called`);
+    }
+}
+export class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!supported) {
+            device.log.error(`MatterbridgeEnergyEvseModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        device.log.info(`MatterbridgeEnergyEvseModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}

package/dist/index.js

@@ -10,9 +10,11 @@ export * from './matterbridgeDeviceTypes.js';
 export * from './matterbridgePlatform.js';
 export * from './matterbridgeAccessoryPlatform.js';
 export * from './matterbridgeDynamicPlatform.js';
+export { addVirtualDevice } from './helpers.js';
 export * from './roboticVacuumCleaner.js';
+export * from './laundryWasher.js';
 export * from './waterHeater.js';
-export { addVirtualDevice } from './helpers.js';
+export * from './evse.js';
 const log = new AnsiLogger({ logName: 'Main', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
 async function main() {
     log.debug('***Matterbridge.loadInstance() called');

package/dist/matterbridgeBehaviors.js

@@ -9,10 +9,7 @@ import { SmokeCoAlarm } from '@matter/main/clusters/smoke-co-alarm';
 import { BooleanStateConfigurationServer } from '@matter/main/behaviors/boolean-state-configuration';
 import { OperationalState } from '@matter/main/clusters/operational-state';
 import { ModeBase } from '@matter/main/clusters/mode-base';
-import { RvcRunMode } from '@matter/main/clusters/rvc-run-mode';
-import { RvcOperationalState } from '@matter/main/clusters/rvc-operational-state';
 import { ServiceArea } from '@matter/main/clusters/service-area';
-import { WaterHeaterManagement } from '@matter/main/clusters/water-heater-management';
 import { IdentifyServer } from '@matter/main/behaviors/identify';
 import { OnOffServer } from '@matter/main/behaviors/on-off';
 import { LevelControlServer } from '@matter/main/behaviors/level-control';
@@ -26,12 +23,8 @@ import { ModeSelectServer } from '@matter/main/behaviors/mode-select';
 import { SmokeCoAlarmServer } from '@matter/main/behaviors/smoke-co-alarm';
 import { SwitchServer } from '@matter/main/behaviors/switch';
 import { OperationalStateServer } from '@matter/main/behaviors/operational-state';
-import { RvcRunModeServer } from '@matter/main/behaviors/rvc-run-mode';
-import { RvcCleanModeServer } from '@matter/main/behaviors/rvc-clean-mode';
-import { RvcOperationalStateServer } from '@matter/main/behaviors/rvc-operational-state';
 import { ServiceAreaServer } from '@matter/main/behaviors/service-area';
-import { WaterHeaterModeServer } from '@matter/main/behaviors/water-heater-mode';
-import { WaterHeaterManagementServer } from '@matter/main/behaviors/water-heater-management';
+import { DeviceEnergyManagementModeServer } from '@matter/main/behaviors/device-energy-management-mode';
 export class MatterbridgeServerDevice {
     log;
     commandHandler;
@@ -189,6 +182,14 @@ export class MatterbridgeServerDevice {
         this.log.info(`Cancel boost (endpoint ${this.endpointId}.${this.endpointNumber})`);
         this.commandHandler.executeHandler('cancelBoost', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
     }
+    enableCharging() {
+        this.log.info(`EnableCharging (endpoint ${this.endpointId}.${this.endpointNumber})`);
+        this.commandHandler.executeHandler('enableCharging', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
+    }
+    disable() {
+        this.log.info(`Disable charging (endpoint ${this.endpointId}.${this.endpointNumber})`);
+        this.commandHandler.executeHandler('disable', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
+    }
 }
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
@@ -495,80 +496,6 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
         };
     }
 }
-export class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
-    changeToMode({ newMode }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
-        if (!supported) {
-            device.log.error(`MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode: ${newMode}`);
-            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
-        }
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
-        if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Cleaning)) {
-            device.log.info('MatterbridgeRvcRunModeServer changeToMode called with newMode Cleaning => Running');
-            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
-            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Running' };
-        }
-        else if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Idle)) {
-            device.log.info('MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => Docked');
-            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Docked;
-            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Docked' };
-        }
-        device.log.info(`MatterbridgeRvcRunModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
-        this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
-        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
-    }
-}
-export class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
-    changeToMode({ newMode }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
-        if (!supported) {
-            device.log.error(`MatterbridgeRvcCleanModeServer changeToMode called with unsupported newMode: ${newMode}`);
-            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
-        }
-        device.changeToMode({ newMode });
-        this.state.currentMode = newMode;
-        device.log.info(`MatterbridgeRvcCleanModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
-        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
-    }
-}
-export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
-    pause() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.log.info('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
-        device.pause();
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
-        this.state.operationalState = RvcOperationalState.OperationalState.Paused;
-        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
-        return {
-            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
-        };
-    }
-    resume() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.log.info('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
-        device.resume();
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
-        this.state.operationalState = RvcOperationalState.OperationalState.Running;
-        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
-        return {
-            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
-        };
-    }
-    goHome() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.log.info('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
-        device.goHome();
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
-        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
-        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
-        return {
-            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
-        };
-    }
-}
 export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
     selectAreas({ newAreas }) {
         const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
@@ -585,31 +512,17 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
         return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
     }
 }
-export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
-    boost({ boostInfo }) {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.boost({ boostInfo });
-        device.log.info(`MatterbridgeWaterHeaterManagementServer boost called with: ${JSON.stringify(boostInfo)}`);
-        this.state.boostState = WaterHeaterManagement.BoostState.Active;
-    }
-    cancelBoost() {
-        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.cancelBoost();
-        device.log.info(`MatterbridgeWaterHeaterManagementServer cancelBoost called`);
-        this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
-    }
-}
-export class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
+export class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyManagementModeServer {
     changeToMode({ newMode }) {
         const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
         if (!supported) {
-            device.log.error(`MatterbridgeWaterHeaterModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            device.log.error(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with unsupported newMode: ${newMode}`);
             return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
         }
         device.changeToMode({ newMode });
         this.state.currentMode = newMode;
-        device.log.info(`MatterbridgeWaterHeaterModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        device.log.info(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
         return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }

package/dist/matterbridgeEndpoint.js

@@ -1,7 +1,7 @@
 import { AnsiLogger, CYAN, YELLOW, db, debugStringify, hk, or, zb } from './logger/export.js';
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidNumber, isValidObject, isValidString } from './utils/export.js';
-import { MatterbridgeServer, MatterbridgeServerDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, } from './matterbridgeBehaviors.js';
+import { MatterbridgeServer, MatterbridgeServerDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, } from './matterbridgeBehaviors.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultOperationalStateClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, invokeBehaviorCommand, triggerEvent, } from './matterbridgeEndpointHelpers.js';
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, UINT16_MAX, UINT32_MAX, VendorId } from '@matter/main';
 import { getClusterNameById, MeasurementType } from '@matter/main/types';
@@ -29,6 +29,8 @@ import { ConcentrationMeasurement } from '@matter/main/clusters/concentration-me
 import { OccupancySensing } from '@matter/main/clusters/occupancy-sensing';
 import { ThermostatUserInterfaceConfiguration } from '@matter/main/clusters/thermostat-user-interface-configuration';
 import { OperationalState } from '@matter/main/clusters/operational-state';
+import { DeviceEnergyManagement } from '@matter/main/clusters/device-energy-management';
+import { DeviceEnergyManagementMode } from '@matter/main/clusters/device-energy-management-mode';
 import { DescriptorServer } from '@matter/main/behaviors/descriptor';
 import { PowerSourceServer } from '@matter/main/behaviors/power-source';
 import { BridgedDeviceBasicInformationServer } from '@matter/main/behaviors/bridged-device-basic-information';
@@ -62,6 +64,7 @@ import { ResourceMonitoring } from '@matter/main/clusters/resource-monitoring';
 import { HepaFilterMonitoringServer } from '@matter/main/behaviors/hepa-filter-monitoring';
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/main/behaviors/activated-carbon-filter-monitoring';
 import { ThermostatUserInterfaceConfigurationServer } from '@matter/main/behaviors/thermostat-user-interface-configuration';
+import { DeviceEnergyManagementServer } from '@matter/main/behaviors/device-energy-management';
 export class MatterbridgeEndpoint extends Endpoint {
     static bridgeMode = '';
     static logLevel = "info";
@@ -139,8 +142,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         else
             this.deviceTypes.set(firstDefinition.code, firstDefinition);
         this.log = new AnsiLogger({ logName: options.uniqueStorageKey ?? 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
-        this.log.debug(`${YELLOW}new${db} MatterbridgeEndpoint: ${zb}${'0x' + firstDefinition.code.toString(16).padStart(4, '0')}${db}-${zb}${firstDefinition.name}${db} ` +
-            `id: ${CYAN}${options.uniqueStorageKey}${db} number: ${CYAN}${options.endpointId}${db} taglist: ${CYAN}${options.tagList ? debugStringify(options.tagList) : 'undefined'}${db}`);
+        this.log.debug(`${YELLOW}new${db} MatterbridgeEndpoint: ${zb}${'0x' + firstDefinition.code.toString(16).padStart(4, '0')}${db}-${zb}${firstDefinition.name}${db} id: ${CYAN}${options.uniqueStorageKey}${db} number: ${CYAN}${options.endpointId}${db} taglist: ${CYAN}${options.tagList ? debugStringify(options.tagList) : 'undefined'}${db}`);
         this.behaviors.require(MatterbridgeServer, { deviceCommand: new MatterbridgeServerDevice(this.log, this.commandHandler, undefined) });
     }
     static async loadInstance(definition, options = {}, debug = false) {
@@ -1041,6 +1043,42 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    createDefaultDeviceEnergyManagementCluster() {
+        this.behaviors.require(DeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting), {
+            forecast: null,
+            esaType: DeviceEnergyManagement.EsaType.Other,
+            esaCanGenerate: false,
+            esaState: DeviceEnergyManagement.EsaState.Offline,
+            absMinPower: 0,
+            absMaxPower: 0,
+        });
+        return this;
+    }
+    createDefaultDeviceEnergyManagementModeCluster(currentMode, supportedModes) {
+        this.behaviors.require(MatterbridgeDeviceEnergyManagementModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'No Energy Management (Forecast reporting only)', mode: 1, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.NoOptimization }] },
+                {
+                    label: 'Device Energy Management',
+                    mode: 2,
+                    modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.DeviceOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }],
+                },
+                {
+                    label: 'Home Energy Management',
+                    mode: 3,
+                    modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.GridOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }],
+                },
+                { label: 'Grid Energy Managemen', mode: 4, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.GridOptimization }] },
+                {
+                    label: 'Full Energy Management',
+                    mode: 5,
+                    modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.DeviceOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }, { value: DeviceEnergyManagementMode.ModeTag.GridOptimization }],
+                },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
     createDefaultPowerTopologyClusterServer() {
         this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.TreeTopology));
         return this;

package/dist/roboticVacuumCleaner.js

@@ -1,7 +1,15 @@
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { roboticVacuumCleaner } from './matterbridgeDeviceTypes.js';
-import { MatterbridgeRvcCleanModeServer, MatterbridgeRvcOperationalStateServer, MatterbridgeRvcRunModeServer, MatterbridgeServiceAreaServer } from './matterbridgeBehaviors.js';
-import { PowerSource, RvcRunMode, RvcCleanMode, RvcOperationalState } from '@matter/main/clusters';
+import { MatterbridgeServer, MatterbridgeServiceAreaServer } from './matterbridgeBehaviors.js';
+import { RvcRunModeServer } from '@matter/main/behaviors/rvc-run-mode';
+import { RvcOperationalStateServer } from '@matter/main/behaviors/rvc-operational-state';
+import { RvcCleanModeServer } from '@matter/main/behaviors/rvc-clean-mode';
+import { PowerSource } from '@matter/main/clusters/power-source';
+import { RvcRunMode } from '@matter/main/clusters/rvc-run-mode';
+import { RvcCleanMode } from '@matter/main/clusters/rvc-clean-mode';
+import { RvcOperationalState } from '@matter/main/clusters/rvc-operational-state';
+import { ModeBase } from '@matter/main/clusters/mode-base';
+import { OperationalState } from '@matter/main/clusters/operational-state';
 export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
     constructor(name, serial, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea) {
         super(roboticVacuumCleaner, { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
@@ -85,3 +93,77 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
         return this;
     }
 }
+export class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!supported) {
+            device.log.error(`MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Cleaning)) {
+            device.log.info('MatterbridgeRvcRunModeServer changeToMode called with newMode Cleaning => Running');
+            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Running' };
+        }
+        else if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Idle)) {
+            device.log.info('MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => Docked');
+            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Docked;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Docked' };
+        }
+        device.log.info(`MatterbridgeRvcRunModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}
+export class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!supported) {
+            device.log.error(`MatterbridgeRvcCleanModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        device.log.info(`MatterbridgeRvcCleanModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}
+export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
+    pause() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
+        device.pause();
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
+        this.state.operationalState = RvcOperationalState.OperationalState.Paused;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    resume() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
+        device.resume();
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
+        this.state.operationalState = RvcOperationalState.OperationalState.Running;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    goHome() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
+        device.goHome();
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
+        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}

package/dist/waterHeater.js

@@ -1,7 +1,11 @@
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { waterHeater } from './matterbridgeDeviceTypes.js';
-import { MatterbridgeWaterHeaterManagementServer, MatterbridgeWaterHeaterModeServer } from './matterbridgeBehaviors.js';
-import { WaterHeaterManagement, WaterHeaterMode } from '@matter/main/clusters';
+import { MatterbridgeServer } from './matterbridgeBehaviors.js';
+import { ModeBase } from '@matter/main/clusters/mode-base';
+import { WaterHeaterManagement } from '@matter/main/clusters/water-heater-management';
+import { WaterHeaterMode } from '@matter/main/clusters/water-heater-mode';
+import { WaterHeaterManagementServer } from '@matter/main/behaviors/water-heater-management';
+import { WaterHeaterModeServer } from '@matter/main/behaviors/water-heater-mode';
 export class WaterHeater extends MatterbridgeEndpoint {
     constructor(name, serial, waterTemperature = 50, targetWaterTemperature = 55, minHeatSetpointLimit = 20, maxHeatSetpointLimit = 80, heaterTypes = { immersionElement1: true }, tankPercentage = 90) {
         super(waterHeater, { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
@@ -9,7 +13,7 @@ export class WaterHeater extends MatterbridgeEndpoint {
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Water Heater')
             .createDefaultPowerSourceWiredClusterServer()
             .createDefaultHeatingThermostatClusterServer(waterTemperature, targetWaterTemperature, minHeatSetpointLimit, maxHeatSetpointLimit)
-            .createDefaultWaterHeaterManagementClusterServer(heaterTypes, heaterTypes, tankPercentage)
+            .createDefaultWaterHeaterManagementClusterServer(heaterTypes, {}, tankPercentage)
             .createDefaultWaterHeaterModeClusterServer();
     }
     createDefaultWaterHeaterManagementClusterServer(heaterTypes, heatDemand, tankPercentage, boostState) {
@@ -43,3 +47,31 @@ export class WaterHeater extends MatterbridgeEndpoint {
         return this;
     }
 }
+export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
+    boost({ boostInfo }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.boost({ boostInfo });
+        device.log.info(`MatterbridgeWaterHeaterManagementServer boost called with: ${JSON.stringify(boostInfo)}`);
+        this.state.boostState = WaterHeaterManagement.BoostState.Active;
+    }
+    cancelBoost() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.cancelBoost();
+        device.log.info(`MatterbridgeWaterHeaterManagementServer cancelBoost called`);
+        this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
+    }
+}
+export class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!supported) {
+            device.log.error(`MatterbridgeWaterHeaterModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        device.log.info(`MatterbridgeWaterHeaterModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.5-dev-20250607-86b467e",
+  "version": "3.0.5-dev-20250607-ef2d8e1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.5-dev-20250607-86b467e",
+      "version": "3.0.5-dev-20250607-ef2d8e1",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.14.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.5-dev-20250607-86b467e",
+  "version": "3.0.5-dev-20250607-ef2d8e1",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",