matterbridge-example-dynamic-platform 1.1.9 → 1.2.0-edge.5

package/CHANGELOG.md

@@ -8,6 +8,24 @@ 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
+
+### 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 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).
+
+### Changed
+
+- [package]: Updated dependencies.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [1.1.9] - 2025-04-07
 
 ### Added

package/dist/appliances.js

@@ -0,0 +1,452 @@
+import { DeviceClasses, DeviceTypeDefinition, MatterbridgeEndpoint, Status, Matterbridge, VendorId, DeviceTypeId, MatterbridgeServer, smokeCoAlarm, MatterbridgeOnOffServer, } from 'matterbridge';
+import { ClusterBehavior, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, EndpointServer, logEndpoint } from 'matterbridge/matter';
+import { Identify, OperationalState, OnOff, TemperatureControl, DishwasherAlarm, DishwasherMode, LaundryWasherControls, LaundryWasherMode, LaundryDryerControls, TemperatureMeasurement, OvenMode, RefrigeratorAndTemperatureControlledCabinetMode, } from 'matterbridge/matter/clusters';
+import { DishwasherAlarmServer, LaundryDryerControlsServer, LaundryWasherControlsServer, OperationalStateBehavior, TemperatureControlBehavior, } from 'matterbridge/matter/behaviors';
+import { OvenCavityOperationalState } from './implementations/ovenCavityOperationalStateCluster.js';
+import { AnsiLogger } from 'matterbridge/logger';
+import { Robot } from './robot.js';
+export class Appliances extends MatterbridgeEndpoint {
+    static temperatureControlledCabinetCooler = DeviceTypeDefinition({
+        name: 'MA-temperaturecontrolledcabinetcooler',
+        code: 0x71,
+        deviceClass: DeviceClasses.Simple,
+        revision: 3,
+        requiredServerClusters: [TemperatureControl.Cluster.id, RefrigeratorAndTemperatureControlledCabinetMode.Cluster.id],
+        optionalServerClusters: [TemperatureMeasurement.Cluster.id],
+    });
+    static temperatureControlledCabinetHeater = DeviceTypeDefinition({
+        name: 'MA-temperaturecontrolledcabinetheater',
+        code: 0x71,
+        deviceClass: DeviceClasses.Simple,
+        revision: 3,
+        requiredServerClusters: [TemperatureControl.Cluster.id, OvenMode.Cluster.id, OvenCavityOperationalState.Cluster.id],
+        optionalServerClusters: [TemperatureMeasurement.Cluster.id],
+    });
+    static laundryWasher = DeviceTypeDefinition({
+        name: 'MA-laundrywasher',
+        code: 0x73,
+        deviceClass: DeviceClasses.Simple,
+        revision: 1,
+        requiredServerClusters: [OperationalState.Cluster.id],
+        optionalServerClusters: [Identify.Cluster.id, LaundryWasherMode.Cluster.id, OnOff.Cluster.id, LaundryWasherControls.Cluster.id, TemperatureControl.Cluster.id],
+    });
+    static laundryDryer = DeviceTypeDefinition({
+        name: 'MA-laundrydryer',
+        code: 0x7c,
+        deviceClass: DeviceClasses.Simple,
+        revision: 1,
+        requiredServerClusters: [OperationalState.Cluster.id],
+        optionalServerClusters: [Identify.Cluster.id, LaundryWasherMode.Cluster.id, OnOff.Cluster.id, LaundryDryerControls.Cluster.id, TemperatureControl.Cluster.id],
+    });
+    static dishwasher = DeviceTypeDefinition({
+        name: 'MA-dishwasher',
+        code: 0x75,
+        deviceClass: DeviceClasses.Simple,
+        revision: 1,
+        requiredServerClusters: [OperationalState.Cluster.id],
+        optionalServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, TemperatureControl.Cluster.id, DishwasherMode.Cluster.id, DishwasherAlarm.Cluster.id],
+    });
+    constructor(deviceType, name, serial) {
+        super(deviceType, { uniqueStorageKey: `${name}-${serial}` });
+        if (deviceType.code === Appliances.laundryWasher.code) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Washer');
+            this.createDeadFrontOnOffClusterServer();
+            this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
+            this.createDefaultLaundryWasherModeClusterServer();
+            this.createSpinLaundryWasherControlsClusterServer(3, ['400', '800', '1200', '1600']);
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.code === Appliances.laundryDryer.code) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Dryer');
+            this.createDeadFrontOnOffClusterServer();
+            this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
+            this.createDefaultLaundryWasherModeClusterServer();
+            this.createDefaultLaundryDryerControlsClusterServer(1);
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.code === Appliances.dishwasher.code) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Dishwasher');
+            this.createDeadFrontOnOffClusterServer();
+            this.createLevelTemperatureControlClusterServer(1, ['Cold', '30°', '40°', '60°']);
+            this.createDefaultDishwasherModeClusterServer();
+            this.createDefaultDishwasherAlarmClusterServer();
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.name === Appliances.temperatureControlledCabinetCooler.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Temperature Controlled Cabinet Cooler');
+            this.createLevelTemperatureControlClusterServer(1, ['Cold', 'Warm', 'Hot']);
+            this.createDefaultTemperatureMeasurementClusterServer(1500);
+            this.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(1);
+        }
+        else if (deviceType.name === Appliances.temperatureControlledCabinetHeater.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Temperature Controlled Cabinet Heater');
+            this.createLevelTemperatureControlClusterServer(1, ['Cold', 'Warm', 'Hot']);
+            this.createDefaultTemperatureMeasurementClusterServer(2500);
+            this.createDefaultOvenModeClusterServer(3);
+            this.createDefaultOvenCavityOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+    }
+    createDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+        this.behaviors.require(MatterbridgeOperationalStateServer, {
+            phaseList: [],
+            currentPhase: null,
+            operationalStateList: [
+                { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Paused, operationalStateLabel: 'Paused' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+            ],
+            operationalState,
+            operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        });
+        return this;
+    }
+    createDefaultOvenCavityOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+        this.behaviors.require(OvenCavityOperationalStateServer, {
+            phaseList: [],
+            currentPhase: null,
+            operationalStateList: [
+                { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+            ],
+            operationalState,
+            operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        });
+        return this;
+    }
+    createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(currentMode) {
+        this.behaviors.require(RefrigeratorAndTemperatureControlledCabinetModeServer, {
+            supportedModes: [
+                { label: 'RapidCool', mode: 1, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
+                { label: 'RapidFreeze', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createDefaultDishwasherModeClusterServer(currentMode) {
+        this.behaviors.require(DishwasherModeServer, {
+            supportedModes: [
+                { label: 'Light', mode: 1, modeTags: [{ value: DishwasherMode.ModeTag.Light }] },
+                { label: 'Normal', mode: 2, modeTags: [{ value: DishwasherMode.ModeTag.Normal }] },
+                { label: 'Heavy', mode: 3, modeTags: [{ value: DishwasherMode.ModeTag.Heavy }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createDefaultLaundryWasherModeClusterServer(currentMode) {
+        this.behaviors.require(LaundryWasherModeServer, {
+            supportedModes: [
+                { label: 'Delicate', mode: 1, modeTags: [{ value: LaundryWasherMode.ModeTag.Delicate }] },
+                { label: 'Normal', mode: 2, modeTags: [{ value: LaundryWasherMode.ModeTag.Normal }] },
+                { label: 'Heavy', mode: 3, modeTags: [{ value: LaundryWasherMode.ModeTag.Heavy }] },
+                { label: 'Whites', mode: 4, modeTags: [{ value: LaundryWasherMode.ModeTag.Whites }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createSpinLaundryWasherControlsClusterServer(spinSpeedCurrent, spinSpeeds) {
+        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin), {
+            spinSpeeds: spinSpeeds ?? ['400', '800', '1200', '1600'],
+            spinSpeedCurrent,
+        });
+        return this;
+    }
+    createRinseLaundryWasherControlsClusterServer(numberOfRinses, supportedRinses) {
+        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Rinse), {
+            supportedRinses: supportedRinses ?? [
+                LaundryWasherControls.NumberOfRinses.None,
+                LaundryWasherControls.NumberOfRinses.Normal,
+                LaundryWasherControls.NumberOfRinses.Extra,
+                LaundryWasherControls.NumberOfRinses.Max,
+            ],
+            numberOfRinses,
+        });
+        return this;
+    }
+    createDefaultLaundryDryerControlsClusterServer(selectedDrynessLevel, supportedDrynessLevels) {
+        this.behaviors.require(LaundryDryerControlsServer, {
+            supportedDrynessLevels: supportedDrynessLevels ?? [
+                LaundryDryerControls.DrynessLevel.Low,
+                LaundryDryerControls.DrynessLevel.Normal,
+                LaundryDryerControls.DrynessLevel.Extra,
+                LaundryDryerControls.DrynessLevel.Max,
+            ],
+            selectedDrynessLevel,
+        });
+        return this;
+    }
+    createDefaultDishwasherAlarmClusterServer() {
+        this.behaviors.require(DishwasherAlarmServer, {
+            mask: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
+            state: { inflowError: false, drainError: false, doorError: false, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
+            supported: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
+        });
+        return this;
+    }
+    createDefaultOvenModeClusterServer(currentMode) {
+        this.behaviors.require(OvenModeServer, {
+            supportedModes: [
+                { label: 'Bake', mode: 1, modeTags: [{ value: OvenMode.ModeTag.Bake }] },
+                { label: 'Convection', mode: 2, modeTags: [{ value: OvenMode.ModeTag.Convection }] },
+                { label: 'Grill', mode: 3, modeTags: [{ value: OvenMode.ModeTag.Grill }] },
+                { label: 'Roast', mode: 4, modeTags: [{ value: OvenMode.ModeTag.Roast }] },
+                { label: 'Clean', mode: 5, modeTags: [{ value: OvenMode.ModeTag.Clean }] },
+                { label: 'Convection Bake', mode: 6, modeTags: [{ value: OvenMode.ModeTag.ConvectionBake }] },
+                { label: 'Convection Roast', mode: 7, modeTags: [{ value: OvenMode.ModeTag.ConvectionRoast }] },
+                { label: 'Warming', mode: 8, modeTags: [{ value: OvenMode.ModeTag.Warming }] },
+                { label: 'Proofing', mode: 9, modeTags: [{ value: OvenMode.ModeTag.Proofing }] },
+                { label: 'Steam', mode: 10, modeTags: [{ value: OvenMode.ModeTag.Steam }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot']) {
+        this.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
+            selectedTemperatureLevel,
+            supportedTemperatureLevels,
+        });
+        return this;
+    }
+    createNumberTemperatureControlClusterServer(temperatureSetpoint, minTemperature, maxTemperature, step = 1) {
+        this.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
+            temperatureSetpoint,
+            minTemperature,
+            maxTemperature,
+            step,
+        });
+        return this;
+    }
+}
+class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer initialized: setting operational state to Stopped');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+    }
+    pause() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: pause called setting operational state to Paused');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    stop() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    start() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: start called setting operational state to Running');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    resume() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: resume called setting operational state to Running');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}
+class MatterbridgeLevelTemperatureControlServer extends TemperatureControlBehavior.with(TemperatureControl.Feature.TemperatureLevel) {
+    initialize() {
+        if (this.state.supportedTemperatureLevels.length >= 2) {
+            const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+            device.log.info('MatterbridgeLevelTemperatureControlServer initialized: setting selectedTemperatureLevel to 1');
+            this.state.selectedTemperatureLevel = 1;
+        }
+    }
+    setTemperature(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (request.targetTemperatureLevel !== undefined && request.targetTemperatureLevel >= 0 && request.targetTemperatureLevel < this.state.supportedTemperatureLevels.length) {
+            device.log.info(`MatterbridgeLevelTemperatureControlServer: setTemperature called setting selectedTemperatureLevel to ${request.targetTemperatureLevel}: ${this.state.supportedTemperatureLevels[request.targetTemperatureLevel]}`);
+            this.state.selectedTemperatureLevel = request.targetTemperatureLevel;
+        }
+        else {
+            device.log.error(`MatterbridgeLevelTemperatureControlServer: setTemperature called with invalid targetTemperatureLevel ${request.targetTemperatureLevel}`);
+        }
+    }
+}
+class MatterbridgeNumberTemperatureControlServer extends TemperatureControlBehavior.with(TemperatureControl.Feature.TemperatureNumber) {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeNumberTemperatureControlServer initialized');
+    }
+    setTemperature(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (request.targetTemperature !== undefined && request.targetTemperature >= this.state.minTemperature && request.targetTemperature <= this.state.maxTemperature) {
+            device.log.info(`MatterbridgeNumberTemperatureControlServer: setTemperature called setting temperatureSetpoint to ${request.targetTemperature}`);
+            this.state.temperatureSetpoint = request.targetTemperature;
+        }
+        else {
+            device.log.error(`MatterbridgeNumberTemperatureControlServer: setTemperature called with invalid targetTemperature ${request.targetTemperature}`);
+        }
+    }
+}
+export const OvenCavityOperationalStateBehavior = ClusterBehavior.withInterface().for(OvenCavityOperationalState.Cluster);
+export class OvenCavityOperationalStateServer extends OvenCavityOperationalStateBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer initialized: setting operational state to Stopped and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+    }
+    stop() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer: stop called setting operational state to Stopped and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    start() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer: start called setting operational state to Running and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}
+export const RefrigeratorAndTemperatureControlledCabinetModeBehavior = ClusterBehavior.withInterface().for(RefrigeratorAndTemperatureControlledCabinetMode.Cluster);
+class RefrigeratorAndTemperatureControlledCabinetModeServer extends RefrigeratorAndTemperatureControlledCabinetModeBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer initialized: setting currentMode to 1');
+        this.state.currentMode = 1;
+    }
+    changeToMode(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (this.state.supportedModes.find((mode) => mode.mode === request.newMode)) {
+            device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with mode ${request.newMode} = ${this.state.supportedModes[request.newMode].label}`);
+            this.state.currentMode = request.newMode;
+            return { status: Status.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+        }
+    }
+}
+export const OvenModeBehavior = ClusterBehavior.withInterface().for(OvenMode.Cluster);
+class OvenModeServer extends OvenModeBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('OvenModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 3;
+    }
+    changeToMode(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (this.state.supportedModes.find((mode) => mode.mode === request.newMode)) {
+            device.log.info(`OvenModeServer: changeToMode called with mode ${request.newMode} = ${this.state.supportedModes[request.newMode].label}`);
+            this.state.currentMode = request.newMode;
+            return { status: Status.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.info(`OvenModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+        }
+    }
+}
+export const DishwasherModeBehavior = ClusterBehavior.withInterface().for(DishwasherMode.Cluster);
+class DishwasherModeServer extends DishwasherModeBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('DishwasherModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 2;
+        this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
+    }
+    handleOnOffChange(onOff) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (onOff === false) {
+            device.log.info('***OnOffServer changed to OFF: setting Dead Front state to Manufacturer Specific');
+            this.state.currentMode = 2;
+        }
+    }
+    changeToMode(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
+        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' };
+        }
+        else {
+            device.log.error(`DishwasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+        }
+    }
+}
+export const LaundryWasherModeBehavior = ClusterBehavior.withInterface().for(LaundryWasherMode.Cluster);
+class LaundryWasherModeServer extends LaundryWasherModeBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('LaundryWasherModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 2;
+        this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
+    }
+    handleOnOffChange(onOff) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (onOff === false) {
+            device.log.info('***OnOffServer changed to OFF: setting Dead Front state to Manufacturer Specific');
+            this.state.currentMode = 2;
+        }
+    }
+    changeToMode(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
+        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' };
+        }
+        else {
+            device.log.error(`LaundryWasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+        }
+    }
+}
+if (process.argv.includes('-testRobot')) {
+    const matterbridge = await Matterbridge.loadInstance(false);
+    matterbridge.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4, logLevel: "debug" });
+    matterbridge.environment.vars.set('log.level', MatterLogLevel.DEBUG);
+    matterbridge.environment.vars.set('log.format', MatterLogFormat.ANSI);
+    matterbridge.environment.vars.set('path.root', 'matterstorage');
+    matterbridge.environment.vars.set('runtime.signals', true);
+    matterbridge.environment.vars.set('runtime.exitcode', true);
+    matterbridge.environment.vars.set('mdns.networkInterface', 'Wi-Fi');
+    await matterbridge.startMatterStorage();
+    const deviceType = smokeCoAlarm;
+    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));
+}

package/dist/implementations/carbonMonoxideConcentrationMeasurement.js

@@ -0,0 +1,113 @@
+import { ClusterBehavior } from 'matterbridge/matter';
+import { Attribute, MutableCluster, OptionalAttribute, TlvEnum, TlvNullable, TlvUInt32, TlvFloat, FixedAttribute, BitFlag, ClusterType, ClusterRegistry, } from 'matterbridge/matter/types';
+export var CarbonMonoxideConcentrationMeasurement;
+(function (CarbonMonoxideConcentrationMeasurement) {
+    let Feature;
+    (function (Feature) {
+        Feature["NumericMeasurement"] = "NumericMeasurement";
+        Feature["LevelIndication"] = "LevelIndication";
+        Feature["MediumLevel"] = "MediumLevel";
+        Feature["CriticalLevel"] = "CriticalLevel";
+        Feature["PeakMeasurement"] = "PeakMeasurement";
+        Feature["AverageMeasurement"] = "AverageMeasurement";
+    })(Feature = CarbonMonoxideConcentrationMeasurement.Feature || (CarbonMonoxideConcentrationMeasurement.Feature = {}));
+    let MeasurementUnit;
+    (function (MeasurementUnit) {
+        MeasurementUnit[MeasurementUnit["Ppm"] = 0] = "Ppm";
+        MeasurementUnit[MeasurementUnit["Ppb"] = 1] = "Ppb";
+        MeasurementUnit[MeasurementUnit["Ppt"] = 2] = "Ppt";
+        MeasurementUnit[MeasurementUnit["Mgm3"] = 3] = "Mgm3";
+        MeasurementUnit[MeasurementUnit["Ugm3"] = 4] = "Ugm3";
+        MeasurementUnit[MeasurementUnit["Ngm3"] = 5] = "Ngm3";
+        MeasurementUnit[MeasurementUnit["Pm3"] = 6] = "Pm3";
+        MeasurementUnit[MeasurementUnit["Bqm3"] = 7] = "Bqm3";
+    })(MeasurementUnit = CarbonMonoxideConcentrationMeasurement.MeasurementUnit || (CarbonMonoxideConcentrationMeasurement.MeasurementUnit = {}));
+    let LevelValue;
+    (function (LevelValue) {
+        LevelValue[LevelValue["Unknown"] = 0] = "Unknown";
+        LevelValue[LevelValue["Low"] = 1] = "Low";
+        LevelValue[LevelValue["Medium"] = 2] = "Medium";
+        LevelValue[LevelValue["High"] = 3] = "High";
+        LevelValue[LevelValue["Critical"] = 4] = "Critical";
+    })(LevelValue = CarbonMonoxideConcentrationMeasurement.LevelValue || (CarbonMonoxideConcentrationMeasurement.LevelValue = {}));
+    let MeasurementMedium;
+    (function (MeasurementMedium) {
+        MeasurementMedium[MeasurementMedium["Air"] = 0] = "Air";
+        MeasurementMedium[MeasurementMedium["Water"] = 1] = "Water";
+        MeasurementMedium[MeasurementMedium["Soil"] = 2] = "Soil";
+    })(MeasurementMedium = CarbonMonoxideConcentrationMeasurement.MeasurementMedium || (CarbonMonoxideConcentrationMeasurement.MeasurementMedium = {}));
+    CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent = MutableCluster.Component({
+        attributes: {
+            measuredValue: Attribute(0x0, TlvNullable(TlvFloat), { default: null }),
+            minMeasuredValue: Attribute(0x1, TlvNullable(TlvFloat), { default: null }),
+            maxMeasuredValue: Attribute(0x2, TlvNullable(TlvFloat), { default: null }),
+            uncertainty: OptionalAttribute(0x7, TlvFloat),
+            measurementUnit: FixedAttribute(0x8, TlvEnum()),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.PeakMeasurementComponent = MutableCluster.Component({
+        attributes: {
+            peakMeasuredValue: Attribute(0x3, TlvNullable(TlvFloat), { default: null }),
+            peakMeasuredValueWindow: Attribute(0x4, TlvUInt32.bound({ max: 604800 }), { default: 1 }),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.AverageMeasurementComponent = MutableCluster.Component({
+        attributes: {
+            averageMeasuredValue: Attribute(0x5, TlvNullable(TlvFloat), { default: null }),
+            averageMeasuredValueWindow: Attribute(0x6, TlvUInt32.bound({ max: 604800 }), { default: 1 }),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.LevelIndicationComponent = MutableCluster.Component({
+        attributes: {
+            levelValue: Attribute(0xa, TlvEnum(), { default: LevelValue.Unknown }),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.Base = MutableCluster.Component({
+        id: 0x40c,
+        name: 'CarbonMonoxideConcentrationMeasurement',
+        revision: 3,
+        features: {
+            numericMeasurement: BitFlag(0),
+            levelIndication: BitFlag(1),
+            mediumLevel: BitFlag(2),
+            criticalLevel: BitFlag(3),
+            peakMeasurement: BitFlag(4),
+            averageMeasurement: BitFlag(5),
+        },
+        attributes: {
+            measurementMedium: FixedAttribute(0x9, TlvEnum()),
+        },
+        extensions: MutableCluster.Extensions({ flags: { numericMeasurement: true }, component: CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent }, { flags: { peakMeasurement: true }, component: CarbonMonoxideConcentrationMeasurement.PeakMeasurementComponent }, { flags: { averageMeasurement: true }, component: CarbonMonoxideConcentrationMeasurement.AverageMeasurementComponent }, { flags: { levelIndication: true }, component: CarbonMonoxideConcentrationMeasurement.LevelIndicationComponent }, { flags: { mediumLevel: true, levelIndication: false }, component: false }, { flags: { criticalLevel: true, levelIndication: false }, component: false }, { flags: { peakMeasurement: true, numericMeasurement: false }, component: false }, { flags: { averageMeasurement: true, numericMeasurement: false }, component: false }, { flags: { numericMeasurement: false, levelIndication: false }, component: false }),
+    });
+    CarbonMonoxideConcentrationMeasurement.ClusterInstance = MutableCluster.ExtensibleOnly(CarbonMonoxideConcentrationMeasurement.Base);
+    CarbonMonoxideConcentrationMeasurement.Cluster = CarbonMonoxideConcentrationMeasurement.ClusterInstance;
+    const MEA = { numericMeasurement: true };
+    const PEA = { peakMeasurement: true };
+    const AVG = { averageMeasurement: true };
+    const LEV = { levelIndication: true };
+    CarbonMonoxideConcentrationMeasurement.CompleteInstance = MutableCluster({
+        id: CarbonMonoxideConcentrationMeasurement.Base.id,
+        name: CarbonMonoxideConcentrationMeasurement.Base.name,
+        revision: CarbonMonoxideConcentrationMeasurement.Base.revision,
+        features: CarbonMonoxideConcentrationMeasurement.Base.features,
+        attributes: {
+            ...CarbonMonoxideConcentrationMeasurement.Base.attributes,
+            measuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.measuredValue, { mandatoryIf: [MEA] }),
+            minMeasuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.minMeasuredValue, { mandatoryIf: [MEA] }),
+            maxMeasuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.maxMeasuredValue, { mandatoryIf: [MEA] }),
+            peakMeasuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.PeakMeasurementComponent.attributes.peakMeasuredValue, { mandatoryIf: [PEA] }),
+            peakMeasuredValueWindow: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.PeakMeasurementComponent.attributes.peakMeasuredValueWindow, { mandatoryIf: [PEA] }),
+            averageMeasuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.AverageMeasurementComponent.attributes.averageMeasuredValue, { mandatoryIf: [AVG] }),
+            averageMeasuredValueWindow: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.AverageMeasurementComponent.attributes.averageMeasuredValueWindow, { mandatoryIf: [AVG] }),
+            uncertainty: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.uncertainty, { optionalIf: [MEA] }),
+            measurementUnit: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.measurementUnit, { mandatoryIf: [MEA] }),
+            levelValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.LevelIndicationComponent.attributes.levelValue, { mandatoryIf: [LEV] }),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.Complete = CarbonMonoxideConcentrationMeasurement.CompleteInstance;
+})(CarbonMonoxideConcentrationMeasurement || (CarbonMonoxideConcentrationMeasurement = {}));
+export const CarbonMonoxideConcentrationMeasurementCluster = CarbonMonoxideConcentrationMeasurement.Cluster;
+ClusterRegistry.register(ClusterType(CarbonMonoxideConcentrationMeasurement.Complete));
+export const CarbonMonoxideConcentrationMeasurementBehavior = ClusterBehavior.for(ClusterType(CarbonMonoxideConcentrationMeasurement.Base));
+export class CarbonMonoxideConcentrationMeasurementServer extends CarbonMonoxideConcentrationMeasurementBehavior.for(ClusterType(CarbonMonoxideConcentrationMeasurement.Base)) {
+}

package/dist/implementations/ovenCavityOperationalStateCluster.js

@@ -0,0 +1,30 @@
+import { OperationalState } from 'matterbridge/matter/clusters';
+import { Attribute, EventPriority, MutableCluster, OptionalAttribute, TlvArray, Event, TlvEnum, TlvNullable, TlvString, TlvUInt32, TlvUInt8, OptionalEvent, ClusterRegistry, TlvNoArguments, Command, } from 'matterbridge/matter/types';
+export var OvenCavityOperationalState;
+(function (OvenCavityOperationalState) {
+    OvenCavityOperationalState.ClusterInstance = MutableCluster({
+        id: 0x48,
+        name: 'OvenCavityOperationalState',
+        revision: 2,
+        attributes: {
+            phaseList: Attribute(0x0, TlvNullable(TlvArray(TlvString, { maxLength: 32 }))),
+            currentPhase: Attribute(0x1, TlvNullable(TlvUInt8)),
+            countdownTime: OptionalAttribute(0x2, TlvNullable(TlvUInt32.bound({ max: 259200 })), { default: null }),
+            operationalStateList: Attribute(0x3, TlvArray(OperationalState.TlvOperationalStateStruct), { default: [] }),
+            operationalState: Attribute(0x4, TlvEnum()),
+            operationalError: Attribute(0x5, OperationalState.TlvErrorStateStruct),
+        },
+        commands: {
+            stop: Command(0x1, TlvNoArguments, 0x4, OperationalState.TlvOperationalCommandResponse),
+            start: Command(0x2, TlvNoArguments, 0x4, OperationalState.TlvOperationalCommandResponse),
+        },
+        events: {
+            operationalError: Event(0x0, EventPriority.Critical, OperationalState.TlvOperationalErrorEvent),
+            operationCompletion: OptionalEvent(0x1, EventPriority.Info, OperationalState.TlvOperationCompletionEvent),
+        },
+    });
+    OvenCavityOperationalState.Cluster = OvenCavityOperationalState.ClusterInstance;
+    OvenCavityOperationalState.Complete = OvenCavityOperationalState.Cluster;
+})(OvenCavityOperationalState || (OvenCavityOperationalState = {}));
+export const OvenCavityOperationalStateCluster = OvenCavityOperationalState.Cluster;
+ClusterRegistry.register(OvenCavityOperationalState.Complete);

package/dist/implementations/roboticVacuumCleanerClusters.js

@@ -0,0 +1,71 @@
+import { OperationalState as OperationalStateNamespace } from 'matterbridge/matter/clusters';
+import { Attribute, ClusterRegistry, Event, EventPriority, MutableCluster, OptionalAttribute, OptionalCommand, OptionalEvent, TlvArray, TlvEnum, TlvField, TlvNoArguments, TlvNullable, TlvObject, TlvOptionalField, TlvString, TlvUInt32, TlvUInt8, } from 'matterbridge/matter/types';
+export var RvcOperationalState;
+(function (RvcOperationalState) {
+    let OperationalState;
+    (function (OperationalState) {
+        OperationalState[OperationalState["Stopped"] = 0] = "Stopped";
+        OperationalState[OperationalState["Running"] = 1] = "Running";
+        OperationalState[OperationalState["Paused"] = 2] = "Paused";
+        OperationalState[OperationalState["Error"] = 3] = "Error";
+        OperationalState[OperationalState["SeekingCharger"] = 64] = "SeekingCharger";
+        OperationalState[OperationalState["Charging"] = 65] = "Charging";
+        OperationalState[OperationalState["Docked"] = 66] = "Docked";
+    })(OperationalState = RvcOperationalState.OperationalState || (RvcOperationalState.OperationalState = {}));
+    RvcOperationalState.TlvOperationalStateStruct = TlvObject({
+        operationalStateId: TlvField(0, TlvEnum()),
+        operationalStateLabel: TlvOptionalField(1, TlvString.bound({ maxLength: 64 })),
+    });
+    let ErrorState;
+    (function (ErrorState) {
+        ErrorState[ErrorState["NoError"] = 0] = "NoError";
+        ErrorState[ErrorState["UnableToStartOrResume"] = 1] = "UnableToStartOrResume";
+        ErrorState[ErrorState["UnableToCompleteOperation"] = 2] = "UnableToCompleteOperation";
+        ErrorState[ErrorState["CommandInvalidInState"] = 3] = "CommandInvalidInState";
+        ErrorState[ErrorState["FailedToFindChargingDock"] = 64] = "FailedToFindChargingDock";
+        ErrorState[ErrorState["Stuck"] = 65] = "Stuck";
+        ErrorState[ErrorState["DustBinMissing"] = 66] = "DustBinMissing";
+        ErrorState[ErrorState["DustBinFull"] = 67] = "DustBinFull";
+        ErrorState[ErrorState["WaterTankEmpty"] = 68] = "WaterTankEmpty";
+        ErrorState[ErrorState["WaterTankMissing"] = 69] = "WaterTankMissing";
+        ErrorState[ErrorState["WaterTankLidOpen"] = 70] = "WaterTankLidOpen";
+        ErrorState[ErrorState["MopCleaningPadMissing"] = 71] = "MopCleaningPadMissing";
+    })(ErrorState = RvcOperationalState.ErrorState || (RvcOperationalState.ErrorState = {}));
+    RvcOperationalState.TlvErrorStateStruct = TlvObject({
+        errorStateId: TlvField(0, TlvEnum()),
+        errorStateLabel: TlvOptionalField(1, TlvString.bound({ maxLength: 64 })),
+        errorStateDetails: TlvOptionalField(2, TlvString.bound({ maxLength: 64 })),
+    });
+    RvcOperationalState.TlvOperationalCommandResponse = TlvObject({
+        commandResponseState: TlvField(0, RvcOperationalState.TlvErrorStateStruct),
+    });
+    RvcOperationalState.TlvOperationalErrorEvent = TlvObject({ errorState: TlvField(0, RvcOperationalState.TlvErrorStateStruct) });
+    RvcOperationalState.ClusterInstance = MutableCluster({
+        id: 0x61,
+        name: 'RvcOperationalState',
+        revision: 2,
+        attributes: {
+            phaseList: Attribute(0x0, TlvNullable(TlvArray(TlvString, { maxLength: 32 }))),
+            currentPhase: Attribute(0x1, TlvNullable(TlvUInt8)),
+            countdownTime: OptionalAttribute(0x2, TlvNullable(TlvUInt32.bound({ max: 259200 })), { default: null }),
+            operationalStateList: Attribute(0x3, TlvArray(RvcOperationalState.TlvOperationalStateStruct), { default: [] }),
+            operationalState: Attribute(0x4, TlvEnum()),
+            operationalError: Attribute(0x5, RvcOperationalState.TlvErrorStateStruct),
+        },
+        commands: {
+            pause: OptionalCommand(0x0, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            stop: OptionalCommand(0x1, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            start: OptionalCommand(0x2, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            resume: OptionalCommand(0x3, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            goHome: OptionalCommand(0x80, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+        },
+        events: {
+            operationalError: Event(0x0, EventPriority.Critical, RvcOperationalState.TlvOperationalErrorEvent),
+            operationCompletion: OptionalEvent(0x1, EventPriority.Info, OperationalStateNamespace.TlvOperationCompletionEvent),
+        },
+    });
+    RvcOperationalState.Cluster = RvcOperationalState.ClusterInstance;
+    RvcOperationalState.Complete = RvcOperationalState.Cluster;
+})(RvcOperationalState || (RvcOperationalState = {}));
+export const RvcOperationalStateCluster = RvcOperationalState.Cluster;
+ClusterRegistry.register(RvcOperationalState.Complete);

package/dist/platform.js

@@ -2,6 +2,8 @@ import { MatterbridgeEndpoint, MatterbridgeDynamicPlatform, airConditioner, airQ
 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';
+import { Appliances } from './appliances.js';
+import { Robot } from './robot.js';
 export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatform {
     switch;
     mountedOnOffSwitch;
@@ -635,7 +637,8 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         this.pump = new MatterbridgeEndpoint([pumpDevice, bridgedNode, powerSource], { uniqueStorageKey: 'Pump' }, this.config.debug)
             .createDefaultBridgedDeviceBasicInformationClusterServer('Pump', '0x96382864PUMP', 0xfff1, 'Matterbridge', 'Matterbridge Pump', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultIdentifyClusterServer()
-            .createDefaultOnOffClusterServer(true)
+            .createOnOffClusterServer()
+            .createLevelControlClusterServer()
             .createDefaultPumpConfigurationAndControlClusterServer()
             .createDefaultPowerSourceWiredClusterServer();
         this.setSelectDevice(this.pump.serialNumber ?? '', this.pump.deviceName ?? '', undefined, 'hub');
@@ -850,6 +853,42 @@ 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);
+        }
+        const laundryWasher = new Appliances(Appliances.laundryWasher, 'Laundry Washer', '1234567890');
+        this.setSelectDevice(laundryWasher.serialNumber ?? '', laundryWasher.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(laundryWasher.deviceName ?? '')) {
+            await this.registerDevice(laundryWasher);
+            this.bridgedDevices.set(laundryWasher.deviceName ?? '', laundryWasher);
+        }
+        const laundryDryer = new Appliances(Appliances.laundryDryer, 'Laundry Dryer', '1235227890');
+        this.setSelectDevice(laundryDryer.serialNumber ?? '', laundryDryer.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(laundryDryer.deviceName ?? '')) {
+            await this.registerDevice(laundryDryer);
+            this.bridgedDevices.set(laundryDryer.deviceName ?? '', laundryDryer);
+        }
+        const dishwasher = new Appliances(Appliances.dishwasher, 'Dishwasher', '0987654321');
+        this.setSelectDevice(dishwasher.serialNumber ?? '', dishwasher.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(dishwasher.deviceName ?? '')) {
+            await this.registerDevice(dishwasher);
+            this.bridgedDevices.set(dishwasher.deviceName ?? '', dishwasher);
+        }
+        const temperatureControlledCabinetCooler = new Appliances(Appliances.temperatureControlledCabinetCooler, 'Temperature Controlled Cabinet Cooler', '0986594321');
+        this.setSelectDevice(temperatureControlledCabinetCooler.serialNumber ?? '', temperatureControlledCabinetCooler.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(temperatureControlledCabinetCooler.deviceName ?? '')) {
+            await this.registerDevice(temperatureControlledCabinetCooler);
+            this.bridgedDevices.set(temperatureControlledCabinetCooler.deviceName ?? '', temperatureControlledCabinetCooler);
+        }
+        const temperatureControlledCabinetHeater = new Appliances(Appliances.temperatureControlledCabinetHeater, 'Temperature Controlled Cabinet Heater', '0986554421');
+        this.setSelectDevice(temperatureControlledCabinetHeater.serialNumber ?? '', temperatureControlledCabinetHeater.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(temperatureControlledCabinetHeater.deviceName ?? '')) {
+            await this.registerDevice(temperatureControlledCabinetHeater);
+            this.bridgedDevices.set(temperatureControlledCabinetHeater.deviceName ?? '', temperatureControlledCabinetHeater);
+        }
     }
     async onConfigure() {
         await super.onConfigure();
@@ -1153,6 +1192,6 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         await super.onShutdown(reason);
         this.log.info('onShutdown called with reason:', reason ?? 'none');
         if (this.config.unregisterOnShutdown === true)
-            await this.unregisterAllDevices();
+            await this.unregisterAllDevices(250);
     }
 }

package/dist/robot.js

@@ -0,0 +1,208 @@
+import { MatterbridgeServer, MatterbridgeEndpoint, roboticVacuumCleaner } from 'matterbridge';
+import { RvcOperationalState } from './implementations/roboticVacuumCleanerClusters.js';
+import { ClusterBehavior } from 'matterbridge/matter';
+import { Status } from 'matterbridge/matter/types';
+import { OperationalState, PowerSource, RvcRunMode, RvcCleanMode, ServiceArea } from 'matterbridge/matter/clusters';
+import { OnOffServer, ServiceAreaBehavior } from 'matterbridge/matter/behaviors';
+export class Robot extends MatterbridgeEndpoint {
+    constructor(name, serial) {
+        super(roboticVacuumCleaner, { uniqueStorageKey: `${name}-${serial}` }, true);
+        this.createDefaultIdentifyClusterServer()
+            .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Robot Vacuum Cleaner')
+            .createDefaultOnOffClusterServer()
+            .createDefaultRvcRunModeClusterServer()
+            .createDefaultRvcOperationalStateClusterServer()
+            .createDefaultRvcCleanModeClusterServer()
+            .createDefaultServiceAreaClusterServer()
+            .createDefaultPowerSourceRechargeableBatteryClusterServer(80, PowerSource.BatChargeLevel.Ok, 5900);
+    }
+    createDefaultRvcRunModeClusterServer() {
+        this.behaviors.require(MatterbridgeRvcRunModeServer, {
+            supportedModes: [
+                { label: 'Idle', mode: 1, modeTags: [{ value: RvcRunMode.ModeTag.Idle }] },
+                { label: 'Cleaning', mode: 2, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }] },
+                { label: 'Mapping', mode: 3, modeTags: [{ value: RvcRunMode.ModeTag.Mapping }] },
+                { label: 'SpotCleaning', mode: 4, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }, { value: RvcRunMode.ModeTag.Max }] },
+            ],
+            currentMode: 1,
+        });
+        return this;
+    }
+    createDefaultRvcCleanModeClusterServer() {
+        this.behaviors.require(MatterbridgeRvcCleanModeServer, {
+            supportedModes: [
+                { label: 'Vacuum', mode: 1, modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }] },
+                { label: 'Mop', mode: 2, modeTags: [{ value: RvcCleanMode.ModeTag.Mop }] },
+                { label: 'Clean', mode: 3, modeTags: [{ value: RvcCleanMode.ModeTag.DeepClean }] },
+            ],
+            currentMode: 1,
+        });
+        return this;
+    }
+    createDefaultServiceAreaClusterServer(supportedAreas, selectedAreas) {
+        this.behaviors.require(MatterbridgeServiceAreaServer, {
+            supportedAreas: supportedAreas ?? [
+                {
+                    areaId: 1,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Living', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 2,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Kitchen', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 3,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Bedroom', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 4,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Bathroom', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+            ],
+            selectedAreas: selectedAreas ?? [],
+            currentArea: 1,
+            estimatedEndTime: null,
+        });
+        return this;
+    }
+    createDefaultRvcOperationalStateClusterServer() {
+        this.behaviors.require(MatterbridgeRvcOperationalStateServer, {
+            phaseList: [],
+            currentPhase: null,
+            operationalStateList: [
+                { operationalStateId: RvcOperationalState.OperationalState.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: RvcOperationalState.OperationalState.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: RvcOperationalState.OperationalState.Paused, operationalStateLabel: 'Paused' },
+                { operationalStateId: RvcOperationalState.OperationalState.Error, operationalStateLabel: 'Error' },
+                { operationalStateId: RvcOperationalState.OperationalState.SeekingCharger, operationalStateLabel: 'SeekingCharger' },
+                { 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' },
+        });
+        return this;
+    }
+}
+export class MatterbridgeServiceAreaServer extends ServiceAreaBehavior {
+    initialize() {
+    }
+    selectAreas({ newAreas }) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        for (const area of newAreas) {
+            const supportedArea = this.state.supportedAreas.find((supportedArea) => supportedArea.areaId === area);
+            if (!supportedArea) {
+                device.log.error('MatterbridgeServiceAreaServer selectAreas called with unsupported area:', area);
+                return { status: ServiceArea.SelectAreasStatus.UnsupportedArea, statusText: 'Unsupported areas' };
+            }
+        }
+        this.state.selectedAreas = newAreas;
+        return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
+    }
+}
+export const RvcRunModeBehavior = ClusterBehavior.withInterface().for(RvcRunMode.Cluster);
+export class MatterbridgeRvcRunModeServer extends RvcRunModeBehavior {
+    initialize() {
+        this.state.currentMode = 1;
+    }
+    changeToMode({ newMode }) {
+        const device = this.agent.get(MatterbridgeServer).state.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: Status.InvalidCommand, statusText: 'Invalid command' };
+        }
+        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: Status.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: Status.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: Status.Success, statusText: 'Success' };
+    }
+}
+export const RvcCleanModeBehavior = ClusterBehavior.withInterface().for(RvcCleanMode.Cluster);
+export class MatterbridgeRvcCleanModeServer extends RvcCleanModeBehavior {
+    initialize() {
+        this.state.currentMode = 1;
+    }
+    changeToMode({ newMode }) {
+        const device = this.agent.get(MatterbridgeServer).state.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' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        device.log.info(`***MatterbridgeRvcCleanModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        return { status: Status.Success, statusText: 'Success' };
+    }
+}
+export const RvcOperationalStateBehavior = ClusterBehavior.withInterface().for(RvcOperationalState.Cluster);
+export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.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' };
+        this.reactTo(this.agent.get(OnOffServer).events.onOff$Changed, this.handleOnOffChange);
+    }
+    handleOnOffChange(onOff) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (onOff) {
+            device.log.info('***OnOffServer changed to ON: setting operational state to Running');
+            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' };
+        }
+        else {
+            device.log.info('***OnOffServer changed to OFF: setting operational state to Docked');
+            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' };
+        }
+    }
+    pause() {
+        const device = this.agent.get(MatterbridgeServer).state.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;
+        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.agent.get(MatterbridgeServer).state.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;
+        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');
+        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/npm-shrinkwrap.json

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

package/package.json

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