matterbridge 3.2.2 → 3.2.3-dev-20250813-099c5df

package/dist/devices/laundryWasher.js

@@ -1,60 +1,13 @@
-/**
- * @description This file contains the LaundryWasher class.
- * @file src/devices/laundryWasher.ts
- * @author Luca Liguori
- * @created 2025-05-25
- * @version 1.1.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { LaundryWasherControls } from '@matter/main/clusters/laundry-washer-controls';
 import { LaundryWasherMode } from '@matter/main/clusters/laundry-washer-mode';
-import { TemperatureControl } from '@matter/main/clusters/temperature-control';
 import { ModeBase } from '@matter/main/clusters/mode-base';
-import { TemperatureControlServer } from '@matter/main/behaviors/temperature-control';
 import { LaundryWasherModeServer } from '@matter/main/behaviors/laundry-washer-mode';
 import { LaundryWasherControlsServer } from '@matter/main/behaviors/laundry-washer-controls';
-// Matterbridge
 import { laundryWasher, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { MatterbridgeOnOffServer, MatterbridgeServer } from '../matterbridgeBehaviors.js';
+import { createLevelTemperatureControlClusterServer, createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class LaundryWasher extends MatterbridgeEndpoint {
-    /**
-     * Creates an instance of the LaundryWasher class.
-     *
-     * @param {string} name - The name of the laundry washer.
-     * @param {string} serial - The serial number of the laundry washer.
-     * @param {number} [currentMode] - The current mode of the laundry washer. Defaults to 2 (Normal mode). Dead Front OnOff Cluster will set this to 2 when turned off. Persistent attribute.
-     * @param {LaundryWasherMode.ModeOption[]} [supportedModes] - The supported modes of the laundry washer. Defaults to a set of common modes (which include Delicate, Normal, Heavy, and Whites). Fixed attribute.
-     * @param {number} [spinSpeedCurrent] - The current spin speed as index of the spinSpeeds array. Defaults to 2 (which corresponds to '1200').
-     * @param {string[]} [spinSpeeds] - The supported spin speeds. Defaults to ['400', '800', '1200', '1600'].
-     * @param {LaundryWasherControls.NumberOfRinses} [numberOfRinses] - The number of rinses. Defaults to LaundryWasherControls.NumberOfRinses.Normal (which corresponds to 1 rinse).
-     * @param {LaundryWasherControls.NumberOfRinses[]} [supportedRinses] - The supported rinses. Defaults to [NumberOfRinses.None, NumberOfRinses.Normal, NumberOfRinses.Max, NumberOfRinses.Extra].
-     * @param {number} [selectedTemperatureLevel] - The selected temperature level as an index of the supportedTemperatureLevels array. Defaults to 1 (which corresponds to 'Warm').
-     * @param {string[]} [supportedTemperatureLevels] - The supported temperature levels. Defaults to ['Cold', 'Warm', 'Hot', '30°', '40°', '60°', '80°']. Fixed attribute.
-     * @param {number} [temperatureSetpoint] - The temperature setpoint * 100. Defaults to 40 * 100 (which corresponds to 40°C).
-     * @param {number} [minTemperature] - The minimum temperature * 100. Defaults to 30 * 100 (which corresponds to 30°C). Fixed attribute.
-     * @param {number} [maxTemperature] - The maximum temperature * 100. Defaults to 60 * 100 (which corresponds to 60°C). Fixed attribute.
-     * @param {number} [step] - The step size for temperature changes. Defaults to 10 * 100 (which corresponds to 10°C). Fixed attribute.
-     * @param {OperationalState.OperationalStateEnum} [operationalState] - The operational state of the laundry washer. Defaults to OperationalState.OperationalStateEnum.Off.
-     *
-     * Remarks:
-     * - If `temperatureSetpoint` is provided, the `createNumberTemperatureControlClusterServer` method will be used to create the TemperatureControl Cluster Server with features TemperatureNumber and TemperatureStep.
-     * - If `temperatureSetpoint` is not provided, the `createLevelTemperatureControlClusterServer` method will be used to create the TemperatureControl Cluster Server with feature TemperatureLevel.
-     */
     constructor(name, serial, currentMode, supportedModes, spinSpeedCurrent, spinSpeeds, numberOfRinses, supportedRinses, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
         super([laundryWasher, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
         this.createDefaultIdentifyClusterServer();
@@ -64,19 +17,11 @@ export class LaundryWasher extends MatterbridgeEndpoint {
         this.createDefaultLaundryWasherModeClusterServer(currentMode, supportedModes);
         this.createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent, spinSpeeds, numberOfRinses, supportedRinses);
         if (temperatureSetpoint)
-            this.createNumberTemperatureControlClusterServer(temperatureSetpoint, minTemperature, maxTemperature, step);
+            createNumberTemperatureControlClusterServer(this, temperatureSetpoint, minTemperature, maxTemperature, step);
         else
-            this.createLevelTemperatureControlClusterServer(selectedTemperatureLevel, supportedTemperatureLevels);
+            createLevelTemperatureControlClusterServer(this, selectedTemperatureLevel, supportedTemperatureLevels);
         this.createDefaultOperationalStateClusterServer(operationalState);
     }
-    /**
-     * Creates a default Laundry Washer Mode Cluster Server.
-     *
-     * @param {number} currentMode - The current mode of the laundry washer. Defaults to 2 (Normal mode). Dead Front OnOff Cluster will set this to 2 when turned off. Persistent attribute.
-     * @param {LaundryWasherMode.ModeOption[]} supportedModes - The supported modes of the laundry washer. Defaults to a set of common modes (which include Delicate, Normal, Heavy, and Whites). Fixed attribute.
-     *
-     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
-     */
     createDefaultLaundryWasherModeClusterServer(currentMode = 2, supportedModes = [
         { label: 'Delicate', mode: 1, modeTags: [{ value: LaundryWasherMode.ModeTag.Delicate }] },
         { label: 'Normal', mode: 2, modeTags: [{ value: LaundryWasherMode.ModeTag.Normal }] },
@@ -84,102 +29,20 @@ export class LaundryWasher extends MatterbridgeEndpoint {
         { label: 'Whites', mode: 4, modeTags: [{ value: LaundryWasherMode.ModeTag.Whites }] },
     ]) {
         this.behaviors.require(MatterbridgeLaundryWasherModeServer, {
-            supportedModes, // Fixed attribute.
-            currentMode, // Persistent attribute.
+            supportedModes,
+            currentMode,
         });
         return this;
     }
-    /**
-     * Creates a Laundry Washer Controls Cluster Server with feature Spin for selecting the spin speed and feature Rinse for selecting the number of rinses.
-     *
-     * @param {number} spinSpeedCurrent - The current spin speed as index of the spinSpeeds array. Default to 2 (which corresponds to '1200').
-     * @param {string[]} spinSpeeds - The supported spin speeds. Default to ['400', '800', '1200', '1600'].
-     * @param {LaundryWasherControls.NumberOfRinses} numberOfRinses - The number of rinses. Default to LaundryWasherControls.NumberOfRinses.Normal (which corresponds to 1 rinse).
-     * @param {LaundryWasherControls.NumberOfRinses[]} supportedRinses - The supported rinses. Default to [NumberOfRinses.None, NumberOfRinses.Normal, NumberOfRinses.Max, NumberOfRinses.Extra].
-     *
-     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
-     */
     createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent = 2, spinSpeeds = ['400', '800', '1200', '1600'], numberOfRinses = LaundryWasherControls.NumberOfRinses.Normal, supportedRinses = [LaundryWasherControls.NumberOfRinses.None, LaundryWasherControls.NumberOfRinses.Normal, LaundryWasherControls.NumberOfRinses.Max, LaundryWasherControls.NumberOfRinses.Extra]) {
         this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin, LaundryWasherControls.Feature.Rinse), {
             spinSpeeds,
-            spinSpeedCurrent, // Writable and nullable
+            spinSpeedCurrent,
             supportedRinses,
-            numberOfRinses, // Writable
+            numberOfRinses,
         });
         return this;
     }
-    /**
-     * Creates a TemperatureControl Cluster Server with feature TemperatureLevel.
-     *
-     * @param {number} selectedTemperatureLevel - The selected temperature level as an index of the supportedTemperatureLevels array. Defaults to 1 (which corresponds to 'Warm').
-     * @param {string[]} supportedTemperatureLevels - The supported temperature levels. Defaults to ['Cold', 'Warm', 'Hot', '30°', '40°', '60°', '80°'].
-     *
-     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
-     */
-    createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot', '30°', '40°', '60°', '80°']) {
-        this.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
-            selectedTemperatureLevel,
-            supportedTemperatureLevels,
-        });
-        return this;
-    }
-    /**
-     * Creates a TemperatureControl Cluster Server with features TemperatureNumber and TemperatureStep.
-     *
-     * @param {number} temperatureSetpoint - The temperature setpoint * 100. Defaults to 40 * 100 (which corresponds to 40°C).
-     * @param {number} minTemperature - The minimum temperature * 100. Defaults to 30 * 100 (which corresponds to 30°C). Fixed attribute.
-     * @param {number} maxTemperature - The maximum temperature * 100. Defaults to 60 * 100 (which corresponds to 60°C). Fixed attribute.
-     * @param {number} [step] - The step size for temperature changes. Defaults to 10 * 100 (which corresponds to 10°C). Fixed attribute.
-     *
-     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
-     */
-    createNumberTemperatureControlClusterServer(temperatureSetpoint = 40 * 100, minTemperature = 30 * 100, maxTemperature = 60 * 100, step = 10 * 100) {
-        this.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
-            temperatureSetpoint,
-            minTemperature, // Fixed attribute
-            maxTemperature, // Fixed attribute
-            step, // Fixed attribute
-        });
-        return this;
-    }
-}
-export class MatterbridgeLevelTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel) {
-    initialize() {
-        if (this.state.supportedTemperatureLevels.length >= 2) {
-            const device = this.endpoint.stateOf(MatterbridgeServer);
-            device.log.info(`MatterbridgeLevelTemperatureControlServer initialized with selectedTemperatureLevel ${this.state.selectedTemperatureLevel} and supportedTemperatureLevels: ${this.state.supportedTemperatureLevels.join(', ')}`);
-        }
-    }
-    setTemperature(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`SetTemperature (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('setTemperature', { request, cluster: TemperatureControlServer.id, attributes: this.state, endpoint: this.endpoint });
-        if (request.targetTemperatureLevel !== undefined && request.targetTemperatureLevel >= 0 && request.targetTemperatureLevel < this.state.supportedTemperatureLevels.length) {
-            device.log.debug(`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}`);
-        }
-    }
-}
-export class MatterbridgeNumberTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep) {
-    initialize() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`MatterbridgeNumberTemperatureControlServer initialized with temperatureSetpoint ${this.state.temperatureSetpoint} minTemperature ${this.state.minTemperature} maxTemperature ${this.state.maxTemperature} step ${this.state.step}`);
-    }
-    setTemperature(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`SetTemperature (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('setTemperature', { request, cluster: TemperatureControlServer.id, attributes: this.state, endpoint: this.endpoint });
-        if (request.targetTemperature !== undefined && request.targetTemperature >= this.state.minTemperature && request.targetTemperature <= this.state.maxTemperature) {
-            device.log.debug(`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 class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
     initialize() {
@@ -187,7 +50,6 @@ export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer
         device.log.info(`MatterbridgeLaundryWasherModeServer initialized: currentMode is ${this.state.currentMode}`);
         this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
     }
-    // Dead Front OnOff Cluster
     handleOnOffChange(onOff) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`HandleOnOffChange (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -212,4 +74,3 @@ export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer
         }
     }
 }
-//# sourceMappingURL=laundryWasher.js.map

package/dist/devices/microwaveOven.js

@@ -0,0 +1,96 @@
+import { OperationalState } from '@matter/main/clusters/operational-state';
+import { MicrowaveOvenMode } from '@matter/main/clusters/microwave-oven-mode';
+import { MicrowaveOvenControl } from '@matter/main/clusters/microwave-oven-control';
+import { MicrowaveOvenControlServer } from '@matter/main/behaviors/microwave-oven-control';
+import { MicrowaveOvenModeServer } from '@matter/main/behaviors/microwave-oven-mode';
+import { microwaveOven, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { MatterbridgeServer, MatterbridgeOperationalStateServer } from '../matterbridgeBehaviors.js';
+export class MicrowaveOven extends MatterbridgeEndpoint {
+    constructor(name, serial, currentMode = 1, supportedModes = [
+        { label: 'Auto', mode: 1, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Auto }] },
+        { label: 'Quick', mode: 2, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quick }] },
+        { label: 'Quiet', mode: 3, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quiet }] },
+        { label: 'Min', mode: 4, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Min }] },
+        { label: 'Max', mode: 5, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Max }] },
+        { label: 'Normal', mode: 6, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Normal }] },
+        { label: 'Defrost', mode: 7, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Defrost }] },
+    ], selectedWattIndex = 5, supportedWatts = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000], cookTime = 60, maxCookTime = 3600) {
+        super([microwaveOven, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        this.createDefaultIdentifyClusterServer();
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Microwave Oven');
+        this.createDefaultPowerSourceWiredClusterServer();
+        this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        this.createDefaultMicrowaveOvenModeClusterServer(currentMode, supportedModes);
+        this.createDefaultMicrowaveOvenControlClusterServer(selectedWattIndex, supportedWatts, cookTime, maxCookTime);
+    }
+    createDefaultMicrowaveOvenModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MicrowaveOvenModeServer, {
+            supportedModes,
+            currentMode,
+        });
+        return this;
+    }
+    createDefaultMicrowaveOvenControlClusterServer(selectedWattIndex, supportedWatts, cookTime, maxCookTime) {
+        this.behaviors.require(MatterbridgeMicrowaveOvenControlServer.with(MicrowaveOvenControl.Feature.PowerInWatts), {
+            supportedWatts,
+            selectedWattIndex,
+            cookTime,
+            maxCookTime,
+        });
+        return this;
+    }
+}
+export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControlServer.with(MicrowaveOvenControl.Feature.PowerInWatts) {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info('MatterbridgeMicrowaveOvenControlServer initialized');
+    }
+    setCookingParameters(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('setCookingParameters', { request, cluster: MicrowaveOvenControl.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        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`);
+            const supportedModes = this.endpoint.stateOf(MicrowaveOvenModeServer).supportedModes;
+            const normalMode = supportedModes.find((mode) => mode.modeTags.some((tag) => tag.value === MicrowaveOvenMode.ModeTag.Normal));
+            this.endpoint.setStateOf(MicrowaveOvenModeServer, { currentMode: normalMode?.mode });
+        }
+        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.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;
+        }
+        if (request.startAfterSetting === true) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting startAfterSetting = true`);
+            this.endpoint.setStateOf(MatterbridgeOperationalStateServer, { operationalState: OperationalState.OperationalStateEnum.Running });
+        }
+    }
+    addMoreTime(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeMicrowaveOvenControlServer: addMoreTime (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('addMoreTime', { request, cluster: MicrowaveOvenControl.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        if (request.timeToAdd !== undefined && request.timeToAdd > 0 && this.state.cookTime + request.timeToAdd <= this.state.maxCookTime) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: addMoreTime called setting cookTime to ${this.state.cookTime + request.timeToAdd}`);
+            this.state.cookTime += request.timeToAdd;
+        }
+        else {
+            device.log.error(`MatterbridgeMicrowaveOvenControlServer: addMoreTime called with invalid cookTime ${request.timeToAdd}`);
+        }
+    }
+}

package/dist/devices/oven.js

@@ -0,0 +1,104 @@
+import { ModeBase } from '@matter/main/clusters/mode-base';
+import { OvenMode } from '@matter/main/clusters/oven-mode';
+import { OperationalState } from '@matter/main/clusters/operational-state';
+import { OvenModeServer } from '@matter/main/behaviors/oven-mode';
+import { OvenCavityOperationalStateServer } from '@matter/main/behaviors/oven-cavity-operational-state';
+import { oven, powerSource, temperatureControlledCabinetHeater } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
+import { createLevelTemperatureControlClusterServer } from './temperatureControl.js';
+export class Oven extends MatterbridgeEndpoint {
+    constructor(name, serial) {
+        super([oven, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        this.createDefaultIdentifyClusterServer();
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Oven');
+        this.createDefaultPowerSourceWiredClusterServer();
+    }
+    addCabinet(name, tagList, currentMode = 2, 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 }] },
+    ], selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Defrost', '180°', '190°', '200°', '250°', '300°'], operationalState = OperationalState.OperationalStateEnum.Stopped, currentPhase, phaseList) {
+        const cabinet = this.addChildDeviceType(name, temperatureControlledCabinetHeater, { tagList }, true);
+        cabinet.log.logName = name;
+        cabinet.createDefaultIdentifyClusterServer();
+        createLevelTemperatureControlClusterServer(cabinet, selectedTemperatureLevel, supportedTemperatureLevels);
+        cabinet.createDefaultTemperatureMeasurementClusterServer(2000);
+        this.createDefaultOvenModeClusterServer(cabinet, currentMode, supportedModes);
+        this.createDefaultOvenCavityOperationalStateClusterServer(cabinet, operationalState, currentPhase, phaseList);
+        return cabinet;
+    }
+    createDefaultOvenModeClusterServer(endpoint, currentMode, supportedModes) {
+        endpoint.behaviors.require(MatterbridgeOvenModeServer, {
+            supportedModes,
+            currentMode,
+        });
+        return endpoint;
+    }
+    createDefaultOvenCavityOperationalStateClusterServer(endpoint, operationalState = OperationalState.OperationalStateEnum.Stopped, currentPhase, phaseList) {
+        endpoint.behaviors.require(MatterbridgeOvenCavityOperationalStateServer, {
+            phaseList: phaseList || null,
+            currentPhase: 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 endpoint;
+    }
+}
+export class MatterbridgeOvenModeServer extends OvenModeServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info('MatterbridgeOvenModeServer initialized');
+    }
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
+        if (supportedMode) {
+            device.log.info(`MatterbridgeOvenModeServer: changeToMode (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) called with mode ${supportedMode.mode} = ${supportedMode.label}`);
+            this.state.currentMode = request.newMode;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.error(`MatterbridgeOvenModeServer: changeToMode (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) called with invalid mode ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+        }
+    }
+}
+export class MatterbridgeOvenCavityOperationalStateServer extends OvenCavityOperationalStateServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info('MatterbridgeOvenCavityOperationalStateServer 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.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOvenCavityOperationalStateServer: stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) 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.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeOvenCavityOperationalStateServer: start (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) 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' },
+        };
+    }
+}

package/dist/devices/roboticVacuumCleaner.js

@@ -1,26 +1,3 @@
-/**
- * @description This file contains the RoboticVacuumCleaner class.
- * @file src/devices/roboticVacuumCleaner.ts
- * @author Luca Liguori
- * @created 2025-05-01
- * @version 1.1.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// Matter.js
 import { AreaNamespaceTag } from '@matter/main';
 import { RvcRunModeServer } from '@matter/main/behaviors/rvc-run-mode';
 import { RvcOperationalStateServer } from '@matter/main/behaviors/rvc-operational-state';
@@ -32,30 +9,10 @@ import { RvcOperationalState } from '@matter/main/clusters/rvc-operational-state
 import { ServiceArea } from '@matter/main/clusters/service-area';
 import { ModeBase } from '@matter/main/clusters/mode-base';
 import { OperationalState } from '@matter/main/clusters/operational-state';
-// Matterbridge
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { powerSource, roboticVacuumCleaner } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeServer, MatterbridgeServiceAreaServer } from '../matterbridgeBehaviors.js';
 export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
-    /**
-     * Creates an instance of the RoboticVacuumCleaner class.
-     *
-     * @param {string} name - The name of the robotic vacuum cleaner.
-     * @param {string} serial - The serial number of the robotic vacuum cleaner.
-     * @param {'server' | 'matter' | undefined} [mode] - The mode of the robotic vacuum cleaner. Defaults to undefined. Use 'server' or 'matter' if you want Apple Home compatibility.
-     * @param {number} [currentRunMode] - The current run mode of the robotic vacuum cleaner. Defaults to 1 (Idle).
-     * @param {RvcRunMode.ModeOption[]} [supportedRunModes] - The supported run modes for the robotic vacuum cleaner. Defaults to a predefined set of modes.
-     * @param {number} [currentCleanMode] - The current clean mode of the robotic vacuum cleaner. Defaults to 1 (Vacuum).
-     * @param {RvcCleanMode.ModeOption[]} [supportedCleanModes] - The supported clean modes for the robotic vacuum cleaner. Defaults to a predefined set of modes.
-     * @param {number | null} [currentPhase] - The current phase of the robotic vacuum cleaner. Defaults to null.
-     * @param {string[] | null} [phaseList] - The list of phases for the robotic vacuum cleaner. Defaults to null.
-     * @param {RvcOperationalState.OperationalState} [operationalState] - The current operational state of the robotic vacuum cleaner. Defaults to Docked.
-     * @param {RvcOperationalState.OperationalStateStruct[]} [operationalStateList] - The list of operational states for the robotic vacuum cleaner. Defaults to a predefined set of states.
-     * @param {ServiceArea.Area[]} [supportedAreas] - The supported areas for the robotic vacuum cleaner. Defaults to a predefined set of areas.
-     * @param {number[]} [selectedAreas] - The selected areas for the robotic vacuum cleaner. Defaults to an empty array (all areas allowed).
-     * @param {number} [currentArea] - The current area of the robotic vacuum cleaner. Defaults to 1 (Living).
-     * @param {ServiceArea.Map[]} [supportedMaps] - The supported maps for the robotic vacuum cleaner. Defaults to empty list.
-     */
     constructor(name, serial, mode = undefined, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea, supportedMaps) {
         super([roboticVacuumCleaner, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, mode }, true);
         this.createDefaultIdentifyClusterServer()
@@ -66,17 +23,6 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
             .createDefaultRvcOperationalStateClusterServer(phaseList, currentPhase, operationalStateList, operationalState)
             .createDefaultServiceAreaClusterServer(supportedAreas, selectedAreas, currentArea, supportedMaps);
     }
-    /**
-     * Creates a default RvcRunMode Cluster Server.
-     *
-     * @param {number} [currentMode] - The current mode of the RvcRunMode cluster. Defaults to 1 (Idle).
-     * @param {RvcRunMode.ModeOption[]} [supportedModes] - The supported modes for the RvcRunMode cluster. Defaults to a predefined set of modes.
-     *
-     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
-     *
-     * @remarks
-     * - supportedModes is a fixed attribute that defines the run modes available for the robotic vacuum cleaner.
-     */
     createDefaultRvcRunModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MatterbridgeRvcRunModeServer, {
             supportedModes: supportedModes ?? [
@@ -89,17 +35,6 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
         });
         return this;
     }
-    /**
-     * Creates a default RvcCleanMode Cluster Server.
-     *
-     * @param {number} [currentMode] - The current mode of the RvcCleanMode cluster. Defaults to 1 (Vacuum).
-     * @param {RvcCleanMode.ModeOption[]} [supportedModes] - The supported modes for the RvcCleanMode cluster. Defaults to a predefined set of modes.
-     *
-     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
-     *
-     * @remarks
-     * - supportedModes is a fixed attribute that defines the clean modes available for the robotic vacuum cleaner.
-     */
     createDefaultRvcCleanModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MatterbridgeRvcCleanModeServer, {
             supportedModes: supportedModes ?? [
@@ -111,15 +46,6 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
         });
         return this;
     }
-    /**
-     * Creates a default ServiceArea Cluster Server.
-     *
-     * @param {ServiceArea.Area[]} [supportedAreas] - The supported areas for the ServiceArea cluster. Defaults to a predefined set of areas.
-     * @param {number[]} [selectedAreas] - The selected areas for the ServiceArea cluster. Defaults to an empty array (all areas allowed).
-     * @param {number} [currentArea] - The current areaId (not the index in the array!) of the ServiceArea cluster. Defaults to 1 (Living).
-     * @param {ServiceArea.Map[]} [supportedMaps] - The supported maps for the robotic vacuum cleaner. Defaults empty list.
-     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
-     */
     createDefaultServiceAreaClusterServer(supportedAreas, selectedAreas, currentArea, supportedMaps) {
         this.behaviors.require(MatterbridgeServiceAreaServer.with(ServiceArea.Feature.Maps), {
             supportedAreas: supportedAreas ?? [
@@ -146,21 +72,11 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
             ],
             selectedAreas: selectedAreas ?? [],
             currentArea: currentArea ?? 1,
-            supportedMaps: supportedMaps ?? [], // Indicates that the device is currently unable to provide this information
+            supportedMaps: supportedMaps ?? [],
             estimatedEndTime: null,
         });
         return this;
     }
-    /**
-     * Creates a default RvcOperationalState Cluster Server.
-     *
-     * @param {string[] | null} [phaseList] - The list of phases for the RvcOperationalState cluster. Defaults to null.
-     * @param {number | null} [currentPhase] - The current phase (the index of the phaseList) of the RvcOperationalState cluster. Defaults to null.
-     * @param {RvcOperationalState.OperationalStateStruct[]} [operationalStateList] - The list of operational states for the RvcOperationalState cluster. Defaults to a predefined set of states.
-     * @param {RvcOperationalState.OperationalState} [operationalState] - The current operationalStateId of the RvcOperationalState cluster. Defaults to Docked.
-     * @param {RvcOperationalState.ErrorStateStruct} [operationalError] - The current operational error of the RvcOperationalState cluster. Defaults to NoError.
-     * @returns {this} The current MatterbridgeEndpoint instance for chaining.
-     */
     createDefaultRvcOperationalStateClusterServer(phaseList = null, currentPhase = null, operationalStateList, operationalState, operationalError) {
         this.behaviors.require(MatterbridgeRvcOperationalStateServer, {
             phaseList,
@@ -170,9 +86,9 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
                 { operationalStateId: RvcOperationalState.OperationalState.Running, operationalStateLabel: 'Running' },
                 { operationalStateId: RvcOperationalState.OperationalState.Paused, operationalStateLabel: 'Paused' },
                 { operationalStateId: RvcOperationalState.OperationalState.Error, operationalStateLabel: 'Error' },
-                { operationalStateId: RvcOperationalState.OperationalState.SeekingCharger, operationalStateLabel: 'SeekingCharger' }, // Y RVC Pause Compatibility N RVC Resume Compatibility
-                { operationalStateId: RvcOperationalState.OperationalState.Charging, operationalStateLabel: 'Charging' }, // N RVC Pause Compatibility Y RVC Resume Compatibility
-                { operationalStateId: RvcOperationalState.OperationalState.Docked, operationalStateLabel: 'Docked' }, // N RVC Pause Compatibility Y RVC Resume Compatibility
+                { operationalStateId: RvcOperationalState.OperationalState.SeekingCharger, operationalStateLabel: 'SeekingCharger' },
+                { operationalStateId: RvcOperationalState.OperationalState.Charging, operationalStateLabel: 'Charging' },
+                { operationalStateId: RvcOperationalState.OperationalState.Docked, operationalStateLabel: 'Docked' },
             ],
             operationalState: operationalState ?? RvcOperationalState.OperationalState.Docked,
             operationalError: operationalError ?? { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' },
@@ -227,7 +143,7 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
         device.log.info(`Pause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         device.commandHandler.executeHandler('pause', { request: {}, cluster: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1; // RvcRunMode.ModeTag.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 {
@@ -239,7 +155,7 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
         device.log.info(`Resume (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         device.commandHandler.executeHandler('resume', { request: {}, cluster: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2; // RvcRunMode.ModeTag.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 {
@@ -247,12 +163,11 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
         };
     }
     goHome() {
-        // const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`GoHome (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         device.commandHandler.executeHandler('goHome', { request: {}, cluster: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
         device.log.debug('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
-        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1; // RvcRunMode.ModeTag.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 {
@@ -260,4 +175,3 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
         };
     }
 }
-//# sourceMappingURL=roboticVacuumCleaner.js.map

package/dist/devices/solarPower.js

@@ -1,45 +1,8 @@
-/**
- * @description This file contains the SolarPower class.
- * @file src/devices/solarPower.ts
- * @author Luca Liguori
- * @contributor Ludovic BOUÉ
- * @created 2025-06-14
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// @matter
 import { PowerSourceTag } from '@matter/main';
 import { DeviceEnergyManagement } from '@matter/main/clusters/device-energy-management';
-// Matterbridge
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { deviceEnergyManagement, electricalSensor, solarPower, powerSource } from '../matterbridgeDeviceTypes.js';
 export class SolarPower extends MatterbridgeEndpoint {
-    /**
-     * Creates an instance of the SolarPower class.
-     *
-     * @param {string} name - The name of the SolarPower.
-     * @param {string} serial - The serial number of the SolarPower.
-     * @param {number} voltage - The voltage value in millivolts.
-     * @param {number} current - The current value in milliamperes.
-     * @param {number} power - The power value in milliwatts.
-     * @param {number} energyExported - The total production value in mW/h.
-     * @param {number} [absMinPower] - Indicate the minimum electrical power in mw that the ESA can consume when switched on. Defaults to `0` if not provided.
-     * @param {number} [absMaxPower] - Indicate the maximum electrical power in mw that the ESA can consume when switched on. Defaults to `0` if not provided.
-     */
     constructor(name, serial, voltage = null, current = null, power = null, energyExported = null, absMinPower = 0, absMaxPower = 0) {
         super([solarPower, powerSource, electricalSensor, deviceEnergyManagement], {
             tagList: [{ mfgCode: null, namespaceId: PowerSourceTag.Solar.namespaceId, tag: PowerSourceTag.Solar.tag, label: null }],
@@ -56,4 +19,3 @@ export class SolarPower extends MatterbridgeEndpoint {
             .addRequiredClusterServers();
     }
 }
-//# sourceMappingURL=solarPower.js.map