matterbridge-example-dynamic-platform 1.2.0-edge.8 → 1.2.0

package/CHANGELOG.md

@@ -8,18 +8,26 @@ 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>
 
-## [1.2.0] - 2025-04-08
+## [1.2.0] - 2025-04-30
 
 ### Added
 
-- [platform]: Added Robot Vacuum Cleaner device (supported by SmartThings, Alexa, Home Assistant and Apple Home).
-- [platform]: Added Laundry Washer deice (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Robot Vacuum Cleaner device (supported by SmartThings, Alexa, Home Assistant and partially by Apple Home). Read carefully the readme please.
+- [platform]: Added OnOff Mounted Switch device (supported by SmartThings, Alexa, Home Assistant).
+- [platform]: Added Dimmer Mounted Switch device (supported by SmartThings, Alexa, Home Assistant).
+- [platform]: Added Laundry Washer device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Laundry Dryer device (supported by SmartThings, Alexa and Home Assistant).
 - [platform]: Added Dishwasher device (supported by SmartThings, Alexa and Home Assistant).
-- [platform]: Added Temperature Controlled Cabinet Cooler device (supported by SmartThings, Alexa and Home Assistant).
-- [platform]: Added Temperature Controlled Cabinet Heater device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Refrigerator device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Oven device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Microwave Oven device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Extractor Hood device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Cooktop device (supported by SmartThings, Alexa and Home Assistant).
 
 ### Changed
 
+- [package]: Require matterbridge 3.0.0.
+- [package]: Updated package.
 - [package]: Updated dependencies.
 
 <a href="https://www.buymeacoffee.com/luligugithub">

package/README.md

@@ -16,7 +16,7 @@
 
 Matterbridge dynamic platform example plugin is a template to develop your own plugin using the dynamic platform.
 
-It exposes:
+It exposes 38 devices:
 
 - a switch with onOff cluster
 - a light with onOff
@@ -46,6 +46,17 @@ It exposes:
 - an airQuality device with all concentration measurements clusters (supported by Apple Home only without the concentration measurements)
 - a momentary switch
 - a latching switch
+- a Robot Vacuum Cleaner device (supported by SmartThings, Alexa, Home Assistant and partially by Apple Home). Read also https://github.com/Luligu/matterbridge/discussions/264.
+- a onOff Mounted Switch device (supported by SmartThings, Alexa, Home Assistant)
+- a dimmer Mounted Switch device (supported by SmartThings, Alexa, Home Assistant)
+- a laundry Washer device (supported by SmartThings, Alexa and Home Assistant)
+- a laundry Dryer device (supported by SmartThings, Alexa and Home Assistant)
+- a dishwasher device (supported by SmartThings, Alexa and Home Assistant)
+- a refrigerator device (supported by SmartThings, Alexa and Home Assistant)
+- an oven device (supported by SmartThings, Alexa and Home Assistant)
+- a microwave Oven device (supported by SmartThings, Alexa and Home Assistant)
+- an extractor Hood device (supported by SmartThings, Alexa and Home Assistant)
+- a cooktop device (supported by SmartThings, Alexa and Home Assistant)
 
 All these devices continuously change state and position. The plugin also shows how to use all the command handlers (you can control all the devices), how to subscribe to attributes and how to trigger events.
 

package/dist/appliances.js

@@ -1,13 +1,14 @@
-import { MatterbridgeEndpoint, MatterbridgeServer, MatterbridgeOnOffServer, Status, RefrigeratorTag, PositionTag, laundryWasher, laundryDryer, dishwasher, refrigerator, temperatureControlledCabinetCooler, oven, temperatureControlledCabinetHeater, microwaveOven, extractorHood, cooktop, cookSurface, } from 'matterbridge';
+import { MatterbridgeEndpoint, MatterbridgeServer, MatterbridgeOnOffServer, RefrigeratorTag, PositionTag, laundryWasher, laundryDryer, dishwasher, refrigerator, temperatureControlledCabinetCooler, oven, temperatureControlledCabinetHeater, microwaveOven, extractorHood, cooktop, cookSurface, powerSource, } from 'matterbridge';
 import { ClusterBehavior } from 'matterbridge/matter';
-import { OperationalState, TemperatureControl, DishwasherMode, LaundryWasherControls, LaundryWasherMode, LaundryDryerControls, OvenMode, RefrigeratorAndTemperatureControlledCabinetMode, MicrowaveOvenMode, MicrowaveOvenControl, OvenCavityOperationalState, } from 'matterbridge/matter/clusters';
+import { OperationalState, TemperatureControl, DishwasherMode, LaundryWasherControls, LaundryWasherMode, LaundryDryerControls, OvenMode, ModeBase, RefrigeratorAndTemperatureControlledCabinetMode, MicrowaveOvenMode, MicrowaveOvenControl, OvenCavityOperationalState, } from 'matterbridge/matter/clusters';
 import { DishwasherAlarmServer, LaundryDryerControlsServer, LaundryWasherControlsServer, MicrowaveOvenControlBehavior, MicrowaveOvenModeServer, OperationalStateBehavior, TemperatureControlBehavior, } from 'matterbridge/matter/behaviors';
 export class Appliances extends MatterbridgeEndpoint {
     constructor(deviceType, name, serial) {
-        super(deviceType, { uniqueStorageKey: `${name}-${serial}` }, true);
+        super([deviceType, powerSource], { uniqueStorageKey: `${name}-${serial}` }, true);
         if (deviceType.code === laundryWasher.code) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Washer');
+            this.createDefaultPowerSourceWiredClusterServer();
             this.createDeadFrontOnOffClusterServer();
             this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
             this.createDefaultLaundryWasherModeClusterServer();
@@ -17,6 +18,7 @@ export class Appliances extends MatterbridgeEndpoint {
         else if (deviceType.code === laundryDryer.code) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Dryer');
+            this.createDefaultPowerSourceWiredClusterServer();
             this.createDeadFrontOnOffClusterServer();
             this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
             this.createDefaultLaundryWasherModeClusterServer();
@@ -26,6 +28,7 @@ export class Appliances extends MatterbridgeEndpoint {
         else if (deviceType.code === dishwasher.code) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Dishwasher');
+            this.createDefaultPowerSourceWiredClusterServer();
             this.createDeadFrontOnOffClusterServer();
             this.createLevelTemperatureControlClusterServer(1, ['Cold', '30°', '40°', '60°']);
             this.createDefaultDishwasherModeClusterServer();
@@ -35,6 +38,7 @@ export class Appliances extends MatterbridgeEndpoint {
         else if (deviceType.name === refrigerator.name) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Refrigerator');
+            this.createDefaultPowerSourceWiredClusterServer();
             const refrigerator = this.addChildDeviceType('Refrigerator', temperatureControlledCabinetCooler, { tagList: [{ mfgCode: null, namespaceId: RefrigeratorTag.Refrigerator.namespaceId, tag: RefrigeratorTag.Refrigerator.tag, label: RefrigeratorTag.Refrigerator.label }] }, true);
             refrigerator.log.logName = `Refrigerator (cabinet Refrigerator)`;
             refrigerator.createDefaultIdentifyClusterServer();
@@ -51,6 +55,7 @@ export class Appliances extends MatterbridgeEndpoint {
         else if (deviceType.name === oven.name) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Oven');
+            this.createDefaultPowerSourceWiredClusterServer();
             const cabinettop = this.addChildDeviceType('Oven (top)', temperatureControlledCabinetHeater, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: PositionTag.Top.label }] }, true);
             cabinettop.log.logName = `Oven (top)`;
             cabinettop.createDefaultIdentifyClusterServer();
@@ -67,6 +72,7 @@ export class Appliances extends MatterbridgeEndpoint {
         else if (deviceType.name === microwaveOven.name) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Microwave Oven');
+            this.createDefaultPowerSourceWiredClusterServer();
             this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
             this.createDefaultMicrowaveOvenModeClusterServer();
             this.createDefaultMicrowaveOvenControlClusterServer();
@@ -74,6 +80,7 @@ export class Appliances extends MatterbridgeEndpoint {
         else if (deviceType.name === extractorHood.name) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Extractor Hood');
+            this.createDefaultPowerSourceWiredClusterServer();
             this.createBaseFanControlClusterServer();
             this.createDefaultHepaFilterMonitoringClusterServer();
             this.createDefaultActivatedCarbonFilterMonitoringClusterServer();
@@ -81,6 +88,7 @@ export class Appliances extends MatterbridgeEndpoint {
         else if (deviceType.name === cooktop.name) {
             this.createDefaultIdentifyClusterServer();
             this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Cooktop');
+            this.createDefaultPowerSourceWiredClusterServer();
             this.createOffOnlyOnOffClusterServer(true);
             const cookSurface1 = this.addChildDeviceType('Surface 1', cookSurface, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Left.namespaceId, tag: PositionTag.Left.tag, label: PositionTag.Left.label }] }, true);
             cookSurface1.log.logName = `Cook surface (right)`;
@@ -365,12 +373,29 @@ class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControlBehavio
     }
     setCookingParameters(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.cookMode !== undefined) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting cookMode to ${request.cookMode}`);
+            this.endpoint.setStateOf(MicrowaveOvenModeServer, { currentMode: request.cookMode });
+        }
+        else {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no cookMode so set to Normal`);
+            this.endpoint.setStateOf(MicrowaveOvenModeServer, { currentMode: 6 });
+        }
+        if (request.cookTime !== undefined && request.cookTime >= 0 && request.cookTime <= this.state.maxCookTime) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting cookTime to ${request.cookTime}`);
+            this.state.cookTime = request.cookTime;
+        }
+        else {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no cookTime so set to 30sec.`);
+            this.state.cookTime = 30;
+        }
         if (request.wattSettingIndex !== undefined && request.wattSettingIndex >= 0 && request.wattSettingIndex < this.state.supportedWatts.length) {
             device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting selectedWattIndex to ${request.wattSettingIndex}`);
             this.state.selectedWattIndex = request.wattSettingIndex;
         }
         else {
-            device.log.error(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with invalid wattSettingIndex ${request.wattSettingIndex}`);
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no wattSettingIndex so set to the highest Watt setting for the selected CookMode`);
+            this.state.selectedWattIndex = this.state.supportedWatts.length - 1;
         }
     }
     addMoreTime(request) {
@@ -424,11 +449,11 @@ class RefrigeratorAndTemperatureControlledCabinetModeServer extends Refrigerator
         if (supportedMode) {
             device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
             this.state.currentMode = request.newMode;
-            return { status: Status.Success, statusText: 'Success' };
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
         }
         else {
             device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with invalid mode ${request.newMode}`);
-            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
         }
     }
 }
@@ -445,11 +470,11 @@ class OvenModeServer extends OvenModeBehavior {
         if (supportedMode) {
             device.log.info(`OvenModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
             this.state.currentMode = request.newMode;
-            return { status: Status.Success, statusText: 'Success' };
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
         }
         else {
             device.log.info(`OvenModeServer: changeToMode called with invalid mode ${request.newMode}`);
-            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
         }
     }
 }
@@ -474,11 +499,11 @@ class DishwasherModeServer extends DishwasherModeBehavior {
         if (supportedMode) {
             device.log.info(`DishwasherModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
             this.state.currentMode = request.newMode;
-            return { status: Status.Success, statusText: 'Success' };
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
         }
         else {
             device.log.error(`DishwasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
-            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
         }
     }
 }
@@ -503,11 +528,11 @@ class LaundryWasherModeServer extends LaundryWasherModeBehavior {
         if (supportedMode) {
             device.log.info(`LaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
             this.state.currentMode = request.newMode;
-            return { status: Status.Success, statusText: 'Success' };
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
         }
         else {
             device.log.error(`LaundryWasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
-            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
         }
     }
 }

package/dist/platform.js

@@ -1,4 +1,4 @@
-import { MatterbridgeEndpoint, MatterbridgeDynamicPlatform, airQualitySensor, bridgedNode, colorTemperatureLight, coverDevice, dimmableLight, doorLockDevice, fanDevice, flowSensor, humiditySensor, onOffLight, onOffOutlet, onOffSwitch, powerSource, rainSensor, smokeCoAlarm, temperatureSensor, thermostatDevice, waterFreezeDetector, waterLeakDetector, airPurifier, pumpDevice, waterValve, genericSwitch, airConditioner, laundryWasher, cooktop, extractorHood, microwaveOven, oven, refrigerator, dishwasher, laundryDryer, onOffMountedSwitch, dimmableMountedSwitch, } from 'matterbridge';
+import { MatterbridgeEndpoint, MatterbridgeDynamicPlatform, airQualitySensor, bridgedNode, colorTemperatureLight, coverDevice, dimmableLight, doorLockDevice, fanDevice, flowSensor, humiditySensor, onOffLight, onOffOutlet, onOffSwitch, powerSource, rainSensor, smokeCoAlarm, temperatureSensor, thermostatDevice, waterFreezeDetector, waterLeakDetector, airPurifier, pumpDevice, waterValve, genericSwitch, airConditioner, laundryWasher, cooktop, extractorHood, microwaveOven, oven, refrigerator, dishwasher, laundryDryer, onOffMountedSwitch, dimmableMountedSwitch, extendedColorLight, } from 'matterbridge';
 import { isValidBoolean, isValidNumber } from 'matterbridge/utils';
 import { LocationTag } from 'matterbridge/matter';
 import { PowerSource, BooleanState, OnOff, LevelControl, AirQuality, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FlowMeasurement, ColorControl, DoorLock, FanControl, FormaldehydeConcentrationMeasurement, NitrogenDioxideConcentrationMeasurement, OzoneConcentrationMeasurement, Pm10ConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, RadonConcentrationMeasurement, RelativeHumidityMeasurement, RelativeHumidityMeasurementCluster, SmokeCoAlarm, TemperatureMeasurement, Thermostat, ThermostatCluster, TotalVolatileOrganicCompoundsConcentrationMeasurement, WindowCovering, } from 'matterbridge/matter/clusters';
@@ -52,18 +52,23 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
     genericSwitchLastEvent = 'Release';
     intervalOnOff = false;
     intervalLevel = 0;
+    intervalColorTemperature = 147;
     bridgedDevices = new Map();
     fanModeLookup = ['Off', 'Low', 'Medium', 'High', 'On', 'Auto', 'Smart'];
     constructor(matterbridge, log, config) {
         super(matterbridge, log, config);
-        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('2.2.7')) {
-            throw new Error(`This plugin requires Matterbridge version >= "2.2.7". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
+        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.0.0')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.0.0". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
         }
         this.log.info('Initializing platform:', this.config.name);
         if (config.whiteList === undefined)
             config.whiteList = [];
         if (config.blackList === undefined)
             config.blackList = [];
+        if (config.enableConcentrationMeasurements === undefined)
+            config.enableConcentrationMeasurements = false;
+        if (config.enableRVC === undefined)
+            config.enableRVC = false;
     }
     async onStart(reason) {
         this.log.info('onStart called with reason:', reason ?? 'none');
@@ -212,7 +217,7 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.dimmer.log);
             this.dimmer?.log.debug(`Command moveToLevelWithOnOff called request: ${level}`);
         });
-        this.light = new MatterbridgeEndpoint([colorTemperatureLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (XY, HS and CT)' }, this.config.debug)
+        this.light = new MatterbridgeEndpoint([extendedColorLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (XY, HS and CT)' }, this.config.debug)
             .createDefaultIdentifyClusterServer()
             .createDefaultGroupsClusterServer()
             .createDefaultBridgedDeviceBasicInformationClusterServer('Light (XY, HS and CT)', '0x23480564', 0xfff1, 'Matterbridge', 'Matterbridge Light', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
@@ -321,7 +326,7 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             await this.lightHS?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', colorTemperatureMireds, this.lightHS?.log);
             this.lightHS?.log.debug(`Command moveToColorTemperature called request: ${colorTemperatureMireds}`);
         });
-        this.lightXY = new MatterbridgeEndpoint([colorTemperatureLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (XY, CT)' }, this.config.debug)
+        this.lightXY = new MatterbridgeEndpoint([extendedColorLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (XY, CT)' }, this.config.debug)
             .createDefaultIdentifyClusterServer()
             .createDefaultGroupsClusterServer()
             .createDefaultBridgedDeviceBasicInformationClusterServer('Light (XY, CT)', '0x23497564', 0xfff1, 'Matterbridge', 'Matterbridge Light', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
@@ -657,11 +662,12 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             if (isValidNumber(newValue, 0, 100))
                 await this.airPurifier?.setAttribute(FanControl.Cluster.id, 'percentCurrent', newValue, this.airPurifier?.log);
         }, this.airPurifier.log);
-        this.airConditioner = new MatterbridgeEndpoint([airConditioner, bridgedNode, powerSource], { uniqueStorageKey: 'Air conditioner' }, this.config.debug)
-            .createDefaultBridgedDeviceBasicInformationClusterServer('Air conditioner', '0x96382864AC', 0xfff1, 'Matterbridge', 'Matterbridge Air conditioner', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+        this.airConditioner = new MatterbridgeEndpoint([airConditioner, bridgedNode, powerSource], { uniqueStorageKey: 'Air Conditioner' }, this.config.debug)
+            .createDefaultBridgedDeviceBasicInformationClusterServer('Air Conditioner', '0x96382864AC', 0xfff1, 'Matterbridge', 'Matterbridge Air Conditioner', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultIdentifyClusterServer()
             .createDeadFrontOnOffClusterServer(true)
             .createDefaultThermostatClusterServer(20, 18, 22)
+            .createDefaultThermostatUserInterfaceConfigurationClusterServer()
             .createDefaultFanControlClusterServer(FanControl.FanMode.Auto)
             .createDefaultTemperatureMeasurementClusterServer(20 * 100)
             .createDefaultRelativeHumidityMeasurementClusterServer(50 * 100)
@@ -736,8 +742,9 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         this.valve?.addCommandHandler('identify', async ({ request: { identifyTime } }) => {
             this.valve?.log.info(`Command identify called identifyTime:${identifyTime}`);
         });
-        this.fan = new MatterbridgeEndpoint([fanDevice, bridgedNode], { uniqueStorageKey: 'Fan' }, this.config.debug)
+        this.fan = new MatterbridgeEndpoint([fanDevice, bridgedNode, powerSource], { uniqueStorageKey: 'Fan' }, this.config.debug)
             .createDefaultBridgedDeviceBasicInformationClusterServer('Fan', 'serial_980545631228', 0xfff1, 'Matterbridge', 'Matterbridge Fan', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultPowerSourceWiredClusterServer()
             .addRequiredClusterServers();
         this.setSelectDevice(this.fan.serialNumber ?? '', this.fan.deviceName ?? '', undefined, 'hub');
         if (this.validateDevice(this.fan.deviceName ?? '')) {
@@ -784,8 +791,9 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             if (isValidNumber(newValue, 0, 100))
                 await this.fan?.setAttribute(FanControl.Cluster.id, 'speedCurrent', newValue, this.fan?.log);
         }, this.fan.log);
-        this.waterLeak = new MatterbridgeEndpoint([waterLeakDetector, bridgedNode], { uniqueStorageKey: 'Water leak detector' }, this.config.debug)
+        this.waterLeak = new MatterbridgeEndpoint([waterLeakDetector, bridgedNode, powerSource], { uniqueStorageKey: 'Water leak detector' }, this.config.debug)
             .createDefaultBridgedDeviceBasicInformationClusterServer('Water leak detector', 'serial_98745631222', 0xfff1, 'Matterbridge', 'Matterbridge WaterLeakDetector', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultPowerSourceRechargeableBatteryClusterServer()
             .createDefaultBooleanStateClusterServer(false)
             .addRequiredClusterServers()
             .addOptionalClusterServers();
@@ -797,8 +805,9 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         else {
             this.waterLeak = undefined;
         }
-        this.waterFreeze = new MatterbridgeEndpoint([waterFreezeDetector, bridgedNode], { uniqueStorageKey: 'Water freeze detector' }, this.config.debug)
+        this.waterFreeze = new MatterbridgeEndpoint([waterFreezeDetector, bridgedNode, powerSource], { uniqueStorageKey: 'Water freeze detector' }, this.config.debug)
             .createDefaultBridgedDeviceBasicInformationClusterServer('Water freeze detector', 'serial_98745631223', 0xfff1, 'Matterbridge', 'Matterbridge WaterFreezeDetector', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultPowerSourceRechargeableBatteryClusterServer()
             .createDefaultBooleanStateClusterServer(false)
             .addRequiredClusterServers()
             .addOptionalClusterServers();
@@ -810,8 +819,9 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         else {
             this.waterFreeze = undefined;
         }
-        this.rain = new MatterbridgeEndpoint([rainSensor, bridgedNode], { uniqueStorageKey: 'Rain sensor' }, this.config.debug)
+        this.rain = new MatterbridgeEndpoint([rainSensor, bridgedNode, powerSource], { uniqueStorageKey: 'Rain sensor' }, this.config.debug)
             .createDefaultBridgedDeviceBasicInformationClusterServer('Rain sensor', 'serial_98745631224', 0xfff1, 'Matterbridge', 'Matterbridge RainSensor', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultPowerSourceRechargeableBatteryClusterServer()
             .createDefaultIdentifyClusterServer()
             .createDefaultBooleanStateClusterServer(false)
             .createDefaultBooleanStateConfigurationClusterServer();
@@ -823,10 +833,11 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         else {
             this.rain = undefined;
         }
-        this.smokeCo = new MatterbridgeEndpoint([smokeCoAlarm, bridgedNode], { uniqueStorageKey: 'SmokeCo alarm sensor' }, this.config.debug)
+        this.smokeCo = new MatterbridgeEndpoint([smokeCoAlarm, bridgedNode, powerSource], { uniqueStorageKey: 'SmokeCo alarm sensor' }, this.config.debug)
             .createDefaultBridgedDeviceBasicInformationClusterServer('SmokeCo alarm sensor', 'serial_94745631225', 0xfff1, 'Matterbridge', 'Matterbridge SmokeCoAlarm', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultIdentifyClusterServer()
-            .createDefaultSmokeCOAlarmClusterServer(SmokeCoAlarm.AlarmState.Normal, SmokeCoAlarm.AlarmState.Normal);
+            .createDefaultSmokeCOAlarmClusterServer(SmokeCoAlarm.AlarmState.Normal, SmokeCoAlarm.AlarmState.Normal)
+            .createDefaultPowerSourceReplaceableBatteryClusterServer();
         if (this.config.enableConcentrationMeasurements === true)
             this.smokeCo.createDefaultCarbonMonoxideConcentrationMeasurementClusterServer(100);
         this.setSelectDevice(this.smokeCo.serialNumber ?? '', this.smokeCo.deviceName ?? '', undefined, 'hub');
@@ -837,10 +848,11 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         else {
             this.smokeCo = undefined;
         }
-        this.smokeOnly = new MatterbridgeEndpoint([smokeCoAlarm, bridgedNode], { uniqueStorageKey: 'Smoke only SmokeCo alarm sensor' }, this.config.debug)
-            .createDefaultBridgedDeviceBasicInformationClusterServer('Smoke only SmokeCo alarm sensor', 'serial_94755661225', 0xfff1, 'Matterbridge', 'Matterbridge SmokeCoAlarm', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+        this.smokeOnly = new MatterbridgeEndpoint([smokeCoAlarm, bridgedNode, powerSource], { uniqueStorageKey: 'Smoke alarm sensor' }, this.config.debug)
+            .createDefaultBridgedDeviceBasicInformationClusterServer('Smoke alarm sensor', 'serial_94755661225', 0xfff1, 'Matterbridge', 'Matterbridge SmokeCoAlarm', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultIdentifyClusterServer()
-            .createSmokeOnlySmokeCOAlarmClusterServer(SmokeCoAlarm.AlarmState.Normal);
+            .createSmokeOnlySmokeCOAlarmClusterServer(SmokeCoAlarm.AlarmState.Normal)
+            .createDefaultPowerSourceReplaceableBatteryClusterServer();
         this.setSelectDevice(this.smokeOnly.serialNumber ?? '', this.smokeOnly.deviceName ?? '', undefined, 'hub');
         if (this.validateDevice(this.smokeOnly.deviceName ?? '')) {
             await this.registerDevice(this.smokeOnly);
@@ -849,10 +861,11 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         else {
             this.smokeOnly = undefined;
         }
-        this.coOnly = new MatterbridgeEndpoint([smokeCoAlarm, bridgedNode], { uniqueStorageKey: 'Co only SmokeCo alarm sensor' }, this.config.debug)
-            .createDefaultBridgedDeviceBasicInformationClusterServer('Co only SmokeCo alarm sensor', 'serial_947456317488', 0xfff1, 'Matterbridge', 'Matterbridge SmokeCoAlarm', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+        this.coOnly = new MatterbridgeEndpoint([smokeCoAlarm, bridgedNode, powerSource], { uniqueStorageKey: 'Co alarm sensor' }, this.config.debug)
+            .createDefaultBridgedDeviceBasicInformationClusterServer('Co alarm sensor', 'serial_947456317488', 0xfff1, 'Matterbridge', 'Matterbridge SmokeCoAlarm', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultIdentifyClusterServer()
-            .createCoOnlySmokeCOAlarmClusterServer(SmokeCoAlarm.AlarmState.Normal);
+            .createCoOnlySmokeCOAlarmClusterServer(SmokeCoAlarm.AlarmState.Normal)
+            .createDefaultPowerSourceReplaceableBatteryClusterServer();
         if (this.config.enableConcentrationMeasurements === true)
             this.coOnly.createDefaultCarbonMonoxideConcentrationMeasurementClusterServer(100);
         this.setSelectDevice(this.coOnly.serialNumber ?? '', this.coOnly.deviceName ?? '', undefined, 'hub');
@@ -863,8 +876,9 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         else {
             this.coOnly = undefined;
         }
-        this.airQuality = new MatterbridgeEndpoint([airQualitySensor, bridgedNode], { uniqueStorageKey: 'Air quality sensor' }, this.config.debug)
+        this.airQuality = new MatterbridgeEndpoint([airQualitySensor, bridgedNode, powerSource], { uniqueStorageKey: 'Air quality sensor' }, this.config.debug)
             .createDefaultBridgedDeviceBasicInformationClusterServer('Air quality sensor', 'serial_987484318322', 0xfff1, 'Matterbridge', 'Matterbridge Air Quality Sensor', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultPowerSourceReplaceableBatteryClusterServer(50, PowerSource.BatChargeLevel.Warning, 2900, 'CR2450', 1)
             .addRequiredClusterServers()
             .addClusterServers([TemperatureMeasurement.Cluster.id, RelativeHumidityMeasurement.Cluster.id]);
         if (this.config.enableConcentrationMeasurements === true) {
@@ -913,11 +927,13 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         else {
             this.latchingSwitch = undefined;
         }
-        const robot = new Robot('Robot Vacuum', '1238777820');
-        this.setSelectDevice(robot.serialNumber ?? '', robot.deviceName ?? '', undefined, 'hub');
-        if (this.validateDevice(robot.deviceName ?? '')) {
-            await this.registerDevice(robot);
-            this.bridgedDevices.set(robot.deviceName ?? '', robot);
+        if (this.config.enableRVC === true) {
+            const robot = new Robot('Robot Vacuum', '1238777820');
+            this.setSelectDevice(robot.serialNumber ?? '', robot.deviceName ?? '', undefined, 'hub');
+            if (this.validateDevice(robot.deviceName ?? '')) {
+                await this.registerDevice(robot);
+                this.bridgedDevices.set(robot.deviceName ?? '', robot);
+            }
         }
         const laundryWasherDevice = new Appliances(laundryWasher, 'Laundry Washer', '1234567890');
         this.setSelectDevice(laundryWasherDevice.serialNumber ?? '', laundryWasherDevice.deviceName ?? '', undefined, 'hub');
@@ -938,12 +954,14 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             this.bridgedDevices.set(dishwasherDevice.deviceName ?? '', dishwasherDevice);
         }
         const refrigeratorDevice = new Appliances(refrigerator, 'Refrigerator', '9987654322');
+        refrigeratorDevice.addFixedLabel('composed', 'Refrigerator');
         this.setSelectDevice(refrigeratorDevice.serialNumber ?? '', refrigeratorDevice.deviceName ?? '', undefined, 'hub');
         if (this.validateDevice(refrigeratorDevice.deviceName ?? '')) {
             await this.registerDevice(refrigeratorDevice);
             this.bridgedDevices.set(refrigeratorDevice.deviceName ?? '', refrigeratorDevice);
         }
         const ovenDevice = new Appliances(oven, 'Oven', '1298867891');
+        ovenDevice.addFixedLabel('composed', 'Oven');
         this.setSelectDevice(ovenDevice.serialNumber ?? '', ovenDevice.deviceName ?? '', undefined, 'hub');
         if (this.validateDevice(ovenDevice.deviceName ?? '')) {
             await this.registerDevice(ovenDevice);
@@ -1043,6 +1061,19 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
                     await this.lightCT?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.lightCT.log);
                     this.log.info(`Set lights currentLevel to ${this.intervalLevel}`);
                 }
+                this.intervalColorTemperature += 50;
+                if (this.intervalColorTemperature > 500) {
+                    this.intervalColorTemperature = 147;
+                }
+                await this.light?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', this.intervalColorTemperature, this.light.log);
+                await this.lightHS?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', this.intervalColorTemperature, this.lightHS.log);
+                await this.lightXY?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', this.intervalColorTemperature, this.lightXY.log);
+                await this.lightCT?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', this.intervalColorTemperature, this.lightCT.log);
+                await this.light?.configureColorControlMode(ColorControl.ColorMode.ColorTemperatureMireds);
+                await this.lightHS?.configureColorControlMode(ColorControl.ColorMode.ColorTemperatureMireds);
+                await this.lightXY?.configureColorControlMode(ColorControl.ColorMode.ColorTemperatureMireds);
+                await this.lightCT?.configureColorControlMode(ColorControl.ColorMode.ColorTemperatureMireds);
+                this.log.info(`Set lights colorTemperatureMireds to ${this.intervalColorTemperature}`);
             }, 60 * 1000 + 200);
         }
         await this.outlet?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.outlet.log);
@@ -1222,6 +1253,24 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
                 }
             }, 60 * 1000 + 1100);
         }
+        const airConditionerDevice = this.bridgedDevices.get('Air Conditioner');
+        await airConditionerDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, airConditionerDevice.log);
+        const laundryWasherDevice = this.bridgedDevices.get('Laundry Washer');
+        await laundryWasherDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, laundryWasherDevice.log);
+        const laundryDryerDevice = this.bridgedDevices.get('Laundry Dryer');
+        await laundryDryerDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, laundryDryerDevice.log);
+        const dishwasherDevice = this.bridgedDevices.get('Dishwasher');
+        await dishwasherDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, dishwasherDevice.log);
+        this.log.info(`Set appliances dead front OnOff to on`);
+        const cooktopDevice = this.bridgedDevices.get('Cooktop');
+        await cooktopDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, cooktopDevice.log);
+        cooktopDevice?.log.info(`Set Cooktop onOff only OnOff to on`);
+        const surface1 = cooktopDevice?.getChildEndpointByName('Surface1');
+        await surface1?.setAttribute(OnOff.Cluster.id, 'onOff', true, surface1.log);
+        surface1?.log.info(`Set Surface 1 onOff only OnOff to on`);
+        const surface2 = cooktopDevice?.getChildEndpointByName('Surface2');
+        await surface2?.setAttribute(OnOff.Cluster.id, 'onOff', true, surface2.log);
+        surface2?.log.info(`Set Surface 2 onOff only OnOff to on`);
         if (this.config.useInterval) {
             this.genericSwitchInterval = setInterval(async () => {
                 if (this.genericSwitchLastEvent === 'Release') {

package/dist/robot.js

@@ -1,8 +1,7 @@
-import { Matterbridge, MatterbridgeServer, MatterbridgeEndpoint, roboticVacuumCleaner } from 'matterbridge';
-import { LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, EndpointServer, logEndpoint, DeviceTypeId, VendorId } from 'matterbridge/matter';
-import { Status } from 'matterbridge/matter/types';
-import { OperationalState, PowerSource, RvcRunMode, RvcCleanMode, RvcOperationalState, ServiceArea } from 'matterbridge/matter/clusters';
-import { RvcCleanModeBehavior, RvcOperationalStateBehavior, RvcRunModeBehavior, ServiceAreaBehavior } from 'matterbridge/matter/behaviors';
+import { Matterbridge, MatterbridgeServer, MatterbridgeEndpoint, roboticVacuumCleaner, dishwasher } from 'matterbridge';
+import { LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, DeviceTypeId, VendorId, } from 'matterbridge/matter';
+import { ModeBase, OperationalState, PowerSource, RvcRunMode, RvcCleanMode, RvcOperationalState, ServiceArea } from 'matterbridge/matter/clusters';
+import { ActionsServer, RvcCleanModeBehavior, RvcOperationalStateBehavior, RvcRunModeBehavior, ServiceAreaBehavior } from 'matterbridge/matter/behaviors';
 import { AnsiLogger } from 'matterbridge/logger';
 export class Robot extends MatterbridgeEndpoint {
     constructor(name, serial) {
@@ -68,11 +67,11 @@ export class Robot extends MatterbridgeEndpoint {
         });
         return this;
     }
-    createDefaultRvcOperationalStateClusterServer() {
+    createDefaultRvcOperationalStateClusterServer(phaseList = null, currentPhase = null, operationalStateList, operationalState, operationalError) {
         this.behaviors.require(MatterbridgeRvcOperationalStateServer, {
-            phaseList: [],
-            currentPhase: null,
-            operationalStateList: [
+            phaseList,
+            currentPhase,
+            operationalStateList: operationalStateList ?? [
                 { operationalStateId: RvcOperationalState.OperationalState.Stopped, operationalStateLabel: 'Stopped' },
                 { operationalStateId: RvcOperationalState.OperationalState.Running, operationalStateLabel: 'Running' },
                 { operationalStateId: RvcOperationalState.OperationalState.Paused, operationalStateLabel: 'Paused' },
@@ -81,8 +80,8 @@ export class Robot extends MatterbridgeEndpoint {
                 { operationalStateId: RvcOperationalState.OperationalState.Charging, operationalStateLabel: 'Charging' },
                 { operationalStateId: RvcOperationalState.OperationalState.Docked, operationalStateLabel: 'Docked' },
             ],
-            operationalState: RvcOperationalState.OperationalState.Docked,
-            operationalError: { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' },
+            operationalState: operationalState ?? RvcOperationalState.OperationalState.Docked,
+            operationalError: operationalError ?? { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' },
         });
         return this;
     }
@@ -91,7 +90,7 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaBehavior {
     initialize() {
     }
     selectAreas({ newAreas }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         for (const area of newAreas) {
             const supportedArea = this.state.supportedAreas.find((supportedArea) => supportedArea.areaId === area);
             if (!supportedArea) {
@@ -100,6 +99,8 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaBehavior {
             }
         }
         this.state.selectedAreas = newAreas;
+        this.state.currentArea = newAreas[0];
+        device.log.info(`***MatterbridgeServiceAreaServer selectAreas called with: ${newAreas.map((area) => area.toString()).join(', ')}`);
         return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
     }
 }
@@ -108,27 +109,27 @@ export class MatterbridgeRvcRunModeServer extends RvcRunModeBehavior {
         this.state.currentMode = 1;
     }
     changeToMode({ newMode }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         const changedMode = this.state.supportedModes.find((mode) => mode.mode === newMode);
         if (!changedMode) {
             device.log.error('MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode:', newMode);
-            return { status: Status.InvalidCommand, statusText: 'Invalid command' };
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
         }
         device.changeToMode({ newMode });
         this.state.currentMode = newMode;
         if (changedMode.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: Status.Success, statusText: 'Running' };
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Running' };
         }
         else if (changedMode.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: Status.Success, statusText: 'Docked' };
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Docked' };
         }
         device.log.info(`***MatterbridgeRvcRunModeServer changeToMode called with newMode ${newMode} => ${changedMode.label}`);
         this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
-        return { status: Status.Success, statusText: 'Success' };
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }
 export class MatterbridgeRvcCleanModeServer extends RvcCleanModeBehavior {
@@ -136,27 +137,27 @@ export class MatterbridgeRvcCleanModeServer extends RvcCleanModeBehavior {
         this.state.currentMode = 1;
     }
     changeToMode({ newMode }) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        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: Status.InvalidCommand, statusText: 'Invalid command' };
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
         }
         device.changeToMode({ newMode });
         this.state.currentMode = newMode;
         device.log.info(`***MatterbridgeRvcCleanModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
-        return { status: Status.Success, statusText: 'Success' };
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
     }
 }
 export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBehavior {
     initialize() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('***MatterbridgeRvcOperationalStateServer initialized: setting operational state to Docked');
         this.state.operationalState = RvcOperationalState.OperationalState.Docked;
         this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
     }
     pause() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
         this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
         this.state.operationalState = RvcOperationalState.OperationalState.Paused;
@@ -166,7 +167,7 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBe
         };
     }
     resume() {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         device.log.info('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
         this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
         this.state.operationalState = RvcOperationalState.OperationalState.Running;
@@ -186,6 +187,13 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBe
         };
     }
 }
+function createEndpointActionsClusterServer(endpoint, endpointLists) {
+    endpoint.behaviors.require(ActionsServer, {
+        actionList: [],
+        endpointLists,
+    });
+    return endpoint;
+}
 if (process.argv.includes('-testRobot')) {
     const matterbridge = await Matterbridge.loadInstance(false);
     matterbridge.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4, logLevel: "debug" });
@@ -196,12 +204,7 @@ if (process.argv.includes('-testRobot')) {
     matterbridge.environment.vars.set('runtime.exitcode', true);
     matterbridge.environment.vars.set('mdns.networkInterface', 'Wi-Fi');
     await matterbridge.startMatterStorage();
-    const deviceType = roboticVacuumCleaner;
-    const context = await matterbridge.createServerNodeContext('Jest', deviceType.name, DeviceTypeId(deviceType.code), VendorId(0xfff1), 'Matterbridge', 0x8000, 'Matterbridge device');
-    const server = await matterbridge.createServerNode(context);
-    const device = new Robot('Robot Vacuum', '99914248654');
-    await server.add(device);
-    logEndpoint(EndpointServer.forEndpoint(device));
-    await matterbridge.startServerNode(server);
-    logEndpoint(EndpointServer.forEndpoint(server));
+    const deviceType = dishwasher;
+    const context = await matterbridge.createServerNodeContext('Matterbridge', deviceType.name, DeviceTypeId(deviceType.code), VendorId(0xfff1), 'Matterbridge', 0x8000, 'Matterbridge device');
+    const server = (await matterbridge.createServerNode(context));
 }

package/matterbridge-example-dynamic-platform.schema.json

@@ -40,9 +40,14 @@
       "default": true
     },
     "enableConcentrationMeasurements": {
-      "description": "Enable the ConcentrationMeasurements in the Air Quality device and SmokeCoSensor devices (Apple Home 18.4 will discard these devices when enabled)",
+      "description": "Enable the ConcentrationMeasurements in the Air Quality device and SmokeCoSensor device (Apple Home 18.4 will discard these devices when enabled)",
       "type": "boolean",
-      "default": true
+      "default": false
+    },
+    "enableRVC": {
+      "description": "Enable the Robot Vacuum Cleaner (Apple Home 18.4 will crash unless you use child bridge and put the rvc in the white list as a single device)",
+      "type": "boolean",
+      "default": false
     },
     "debug": {
       "description": "Enable the debug for the plugin (development only)",

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge-example-dynamic-platform",
-  "version": "1.2.0-edge.8",
+  "version": "1.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge-example-dynamic-platform",
-      "version": "1.2.0-edge.8",
+      "version": "1.2.0",
       "license": "MIT",
       "dependencies": {
         "node-ansi-logger": "3.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-example-dynamic-platform",
-  "version": "1.2.0-edge.8",
+  "version": "1.2.0",
   "description": "Matterbridge dynamic plugin",
   "author": "https://github.com/Luligu",
   "license": "MIT",

package/tsconfig.jest.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    // enable isolatedModules just for ts-jest
+    "isolatedModules": true
+  },
+  "include": ["**/*.spec.ts", "**/*.test.ts", "**/__test__/*"]
+}