matterbridge 3.2.3-dev-20250812-77f592b → 3.2.3-dev-20250813-34745fd

package/CHANGELOG.md

@@ -10,6 +10,16 @@ If you like this project and find it useful, please consider giving it a star on
 
 ## [3.2.3] - 2025-08-??
 
+### Added
+
+- [Oven]: Added Oven class and Jest test. It is not supported by the Home app.
+- [MicrowaveOven]: Added MicrowaveOven class and Jest test. It is not supported by the Home app.
+- [Matter]: Added Matter Specification Version 1.4 pdf files.
+
+### Changed
+
+- [package]: Updated dependencies.
+
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
 </a>

package/dist/devices/dishwasher.js

@@ -6,7 +6,7 @@ import { DishwasherMode } from '@matter/main/clusters/dishwasher-mode';
 import { dishwasher, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { MatterbridgeOnOffServer, MatterbridgeServer } from '../matterbridgeBehaviors.js';
-import { MatterbridgeLevelTemperatureControlServer, MatterbridgeNumberTemperatureControlServer } from './laundryWasher.js';
+import { MatterbridgeLevelTemperatureControlServer, MatterbridgeNumberTemperatureControlServer } from './temperatureControl.js';
 export class Dishwasher extends MatterbridgeEndpoint {
     constructor(name, serial, currentMode, supportedModes, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
         super([dishwasher, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);

package/dist/devices/export.js

@@ -1,10 +1,12 @@
-export * from './roboticVacuumCleaner.js';
 export * from './laundryWasher.js';
 export * from './laundryDryer.js';
+export * from './extractorHood.js';
+export * from './dishwasher.js';
+export * from './microwaveOven.js';
+export * from './oven.js';
 export * from './waterHeater.js';
 export * from './evse.js';
 export * from './solarPower.js';
 export * from './batteryStorage.js';
 export * from './heatPump.js';
-export * from './extractorHood.js';
-export * from './dishwasher.js';
+export * from './roboticVacuumCleaner.js';

package/dist/devices/laundryDryer.js

@@ -4,7 +4,8 @@ import { LaundryDryerControls } from '@matter/main/clusters/laundry-dryer-contro
 import { LaundryDryerControlsServer } from '@matter/main/behaviors/laundry-dryer-controls';
 import { laundryDryer, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-import { MatterbridgeLaundryWasherModeServer, MatterbridgeLevelTemperatureControlServer, MatterbridgeNumberTemperatureControlServer } from './laundryWasher.js';
+import { MatterbridgeLaundryWasherModeServer } from './laundryWasher.js';
+import { MatterbridgeLevelTemperatureControlServer, MatterbridgeNumberTemperatureControlServer } from './temperatureControl.js';
 export class LaundryDryer extends MatterbridgeEndpoint {
     constructor(name, serial, currentMode, supportedModes, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
         super([laundryDryer, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);

package/dist/devices/laundryWasher.js

@@ -1,13 +1,12 @@
 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';
 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 {
     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);
@@ -18,9 +17,9 @@ 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);
     }
     createDefaultLaundryWasherModeClusterServer(currentMode = 2, supportedModes = [
@@ -44,60 +43,6 @@ export class LaundryWasher extends MatterbridgeEndpoint {
         });
         return this;
     }
-    createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot', '30°', '40°', '60°', '80°']) {
-        this.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
-            selectedTemperatureLevel,
-            supportedTemperatureLevels,
-        });
-        return this;
-    }
-    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,
-            maxTemperature,
-            step,
-        });
-        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() {

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/temperatureControl.js

@@ -0,0 +1,57 @@
+import { TemperatureControl } from '@matter/main/clusters/temperature-control';
+import { TemperatureControlServer } from '@matter/main/behaviors/temperature-control';
+import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
+export function createLevelTemperatureControlClusterServer(endpoint, selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot', '30°', '40°', '60°', '80°']) {
+    endpoint.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
+        selectedTemperatureLevel,
+        supportedTemperatureLevels,
+    });
+    return endpoint;
+}
+export function createNumberTemperatureControlClusterServer(endpoint, temperatureSetpoint = 40 * 100, minTemperature = 30 * 100, maxTemperature = 60 * 100, step = 10 * 100) {
+    endpoint.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
+        temperatureSetpoint,
+        minTemperature,
+        maxTemperature,
+        step,
+    });
+    return endpoint;
+}
+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}`);
+        }
+    }
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.2.3-dev-20250812-77f592b",
+  "version": "3.2.3-dev-20250813-34745fd",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.2.3-dev-20250812-77f592b",
+      "version": "3.2.3-dev-20250813-34745fd",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.2.3-dev-20250812-77f592b",
+  "version": "3.2.3-dev-20250813-34745fd",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",