@matterbridge/core 3.6.2-dev-20260317-e291a17 → 3.7.0-dev-20260318-5bb831c

package/dist/devices/temperatureControl.js

@@ -22,10 +22,16 @@ export class MatterbridgeLevelTemperatureControlServer extends TemperatureContro
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeLevelTemperatureControlServer initialized with selectedTemperatureLevel ${this.state.selectedTemperatureLevel} and supportedTemperatureLevels: ${this.state.supportedTemperatureLevels.join(', ')}`);
     }
-    setTemperature(request) {
+    async 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 });
+        await device.commandHandler.executeHandler('TemperatureControl.setTemperature', {
+            command: '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;
@@ -40,10 +46,16 @@ export class MatterbridgeNumberTemperatureControlServer extends TemperatureContr
         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) {
+    async 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 });
+        await device.commandHandler.executeHandler('TemperatureControl.setTemperature', {
+            command: '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;

package/dist/devices/waterHeater.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { WaterHeaterManagementServer } from '@matter/node/behaviors/water-heater-management';
 import { WaterHeaterModeServer } from '@matter/node/behaviors/water-heater-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
@@ -29,9 +28,9 @@ export declare class WaterHeater extends MatterbridgeEndpoint {
     createDefaultWaterHeaterModeClusterServer(currentMode?: number, supportedModes?: WaterHeaterMode.ModeOption[]): this;
 }
 export declare class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
-    boost(request: WaterHeaterManagement.BoostRequest): MaybePromise;
-    cancelBoost(): MaybePromise;
+    boost(request: WaterHeaterManagement.BoostRequest): Promise<void>;
+    cancelBoost(): Promise<void>;
 }
 export declare class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
-    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+    changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }

package/dist/devices/waterHeater.js

@@ -59,26 +59,44 @@ export class WaterHeater extends MatterbridgeEndpoint {
     }
 }
 export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
-    boost(request) {
+    async boost(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Boost (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('boost', { request, cluster: WaterHeaterManagementServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WaterHeaterManagement.boost', {
+            command: 'boost',
+            request,
+            cluster: WaterHeaterManagementServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeWaterHeaterManagementServer boost called with: ${JSON.stringify(request)}`);
         this.state.boostState = WaterHeaterManagement.BoostState.Active;
     }
-    cancelBoost() {
+    async cancelBoost() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Cancel boost (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('cancelBoost', { request: {}, cluster: WaterHeaterManagementServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WaterHeaterManagement.cancelBoost', {
+            command: 'cancelBoost',
+            request: {},
+            cluster: WaterHeaterManagementServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeWaterHeaterManagementServer cancelBoost called`);
         this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
     }
 }
 export class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
-    changeToMode(request) {
+    async changeToMode(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Changing mode to ${request.newMode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('changeToMode', { request, cluster: WaterHeaterModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WaterHeaterMode.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: WaterHeaterModeServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
             device.log.error(`MatterbridgeWaterHeaterModeServer changeToMode called with unsupported newMode: ${request.newMode}`);

package/dist/export.d.ts

@@ -4,6 +4,7 @@ export * from './matterbridgeBehaviorsServer.js';
 export * from './matterbridgeDeviceTypes.js';
 export * from './matterbridgeDynamicPlatform.js';
 export * from './matterbridgeEndpoint.js';
+export * from './matterbridgeEndpointCommandHandler.js';
 export * from './matterbridgeEndpointHelpers.js';
 export * from './matterbridgeEndpointTypes.js';
 export * from './matterbridgePlatform.js';

package/dist/export.js

@@ -6,6 +6,7 @@ export * from './matterbridgeBehaviorsServer.js';
 export * from './matterbridgeDeviceTypes.js';
 export * from './matterbridgeDynamicPlatform.js';
 export * from './matterbridgeEndpoint.js';
+export * from './matterbridgeEndpointCommandHandler.js';
 export * from './matterbridgeEndpointHelpers.js';
 export * from './matterbridgeEndpointTypes.js';
 export * from './matterbridgePlatform.js';

package/dist/jestutils/jestHelpers.js

@@ -255,7 +255,7 @@ export async function createMatterbridgeEnvironment(name, createOnly = false) {
     matterbridge = await Matterbridge.loadInstance(false);
     expect(matterbridge).toBeDefined();
     expect(matterbridge).toBeInstanceOf(Matterbridge);
-    matterbridge.matterbridgeVersion = '3.6.2';
+    matterbridge.matterbridgeVersion = '3.7.0';
     matterbridge.bridgeMode = 'bridge';
     matterbridge.rootDirectory = path.join(HOMEDIR);
     matterbridge.homeDirectory = path.join(HOMEDIR);

package/dist/matterbridgeBehaviorsServer.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise, NamedHandler } from '@matter/general';
+import { MaybePromise } from '@matter/general';
 import { Behavior } from '@matter/node';
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
@@ -20,10 +20,12 @@ import { SwitchServer } from '@matter/node/behaviors/switch';
 import { ThermostatServer } from '@matter/node/behaviors/thermostat';
 import { ValveConfigurationAndControlServer } from '@matter/node/behaviors/valve-configuration-and-control';
 import { MovementDirection, MovementType, WindowCoveringServer } from '@matter/node/behaviors/window-covering';
+import { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
 import { ColorControl } from '@matter/types/clusters/color-control';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { FanControl } from '@matter/types/clusters/fan-control';
+import { HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
 import { Identify } from '@matter/types/clusters/identify';
 import { LevelControl } from '@matter/types/clusters/level-control';
 import { ModeBase } from '@matter/types/clusters/mode-base';
@@ -36,7 +38,7 @@ import { Thermostat } from '@matter/types/clusters/thermostat';
 import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 import { AnsiLogger } from 'node-ansi-logger';
-import { MatterbridgeEndpointCommands } from './matterbridgeEndpointTypes.js';
+import { CommandHandler } from './matterbridgeEndpointCommandHandler.js';
 export declare class MatterbridgeServer extends Behavior {
     static readonly id = "matterbridge";
     state: MatterbridgeServer.State;
@@ -45,24 +47,24 @@ export declare class MatterbridgeServer extends Behavior {
 export declare namespace MatterbridgeServer {
     class State {
         log: AnsiLogger;
-        commandHandler: NamedHandler<MatterbridgeEndpointCommands>;
+        commandHandler: CommandHandler;
     }
 }
 export declare class MatterbridgePowerSourceServer extends PowerSourceServer {
     initialize(): Promise<void>;
 }
 export declare class MatterbridgeIdentifyServer extends IdentifyServer {
-    identify(request: Identify.IdentifyRequest): MaybePromise;
-    triggerEffect(request: Identify.TriggerEffectRequest): MaybePromise;
+    identify(request: Identify.IdentifyRequest): Promise<void>;
+    triggerEffect(request: Identify.TriggerEffectRequest): Promise<void>;
 }
 export declare class MatterbridgeOnOffServer extends OnOffServer {
-    on(): MaybePromise;
-    off(): MaybePromise;
-    toggle(): MaybePromise;
+    on(): Promise<void>;
+    off(): Promise<void>;
+    toggle(): Promise<void>;
 }
 export declare class MatterbridgeLevelControlServer extends LevelControlServer {
-    moveToLevel(request: LevelControl.MoveToLevelRequest): MaybePromise;
-    moveToLevelWithOnOff(request: LevelControl.MoveToLevelRequest): MaybePromise;
+    moveToLevel(request: LevelControl.MoveToLevelRequest): Promise<void>;
+    moveToLevelWithOnOff(request: LevelControl.MoveToLevelRequest): Promise<void>;
 }
 declare const MatterbridgeColorControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 768;
@@ -452,11 +454,11 @@ declare const MatterbridgeColorControlServer_base: import("@matter/node").Cluste
     }];
 }>, readonly [ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature]>, typeof ColorControlServer, import("@matter/node/behaviors/color-control").ColorControlInterface>;
 export declare class MatterbridgeColorControlServer extends MatterbridgeColorControlServer_base {
-    moveToHue(request: ColorControl.MoveToHueRequest): MaybePromise;
-    moveToSaturation(request: ColorControl.MoveToSaturationRequest): MaybePromise;
-    moveToHueAndSaturation(request: ColorControl.MoveToHueAndSaturationRequest): MaybePromise;
-    moveToColor(request: ColorControl.MoveToColorRequest): MaybePromise;
-    moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): MaybePromise;
+    moveToHue(request: ColorControl.MoveToHueRequest): Promise<void>;
+    moveToSaturation(request: ColorControl.MoveToSaturationRequest): Promise<void>;
+    moveToHueAndSaturation(request: ColorControl.MoveToHueAndSaturationRequest): Promise<void>;
+    moveToColor(request: ColorControl.MoveToColorRequest): Promise<void>;
+    moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): Promise<void>;
 }
 declare const MatterbridgeEnhancedColorControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 768;
@@ -846,13 +848,13 @@ declare const MatterbridgeEnhancedColorControlServer_base: import("@matter/node"
     }];
 }>, readonly [ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature]>, typeof ColorControlServer, import("@matter/node/behaviors/color-control").ColorControlInterface>;
 export declare class MatterbridgeEnhancedColorControlServer extends MatterbridgeEnhancedColorControlServer_base {
-    moveToHue(request: ColorControl.MoveToHueRequest): MaybePromise;
-    enhancedMoveToHue(request: ColorControl.EnhancedMoveToHueRequest): MaybePromise;
-    moveToSaturation(request: ColorControl.MoveToSaturationRequest): MaybePromise;
-    moveToHueAndSaturation(request: ColorControl.MoveToHueAndSaturationRequest): MaybePromise;
-    enhancedMoveToHueAndSaturation(request: ColorControl.EnhancedMoveToHueAndSaturationRequest): MaybePromise;
-    moveToColor(request: ColorControl.MoveToColorRequest): MaybePromise;
-    moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): MaybePromise;
+    moveToHue(request: ColorControl.MoveToHueRequest): Promise<void>;
+    enhancedMoveToHue(request: ColorControl.EnhancedMoveToHueRequest): Promise<void>;
+    moveToSaturation(request: ColorControl.MoveToSaturationRequest): Promise<void>;
+    moveToHueAndSaturation(request: ColorControl.MoveToHueAndSaturationRequest): Promise<void>;
+    enhancedMoveToHueAndSaturation(request: ColorControl.EnhancedMoveToHueAndSaturationRequest): Promise<void>;
+    moveToColor(request: ColorControl.MoveToColorRequest): Promise<void>;
+    moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): Promise<void>;
 }
 declare const MatterbridgeLiftWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 258;
@@ -1043,10 +1045,10 @@ declare const MatterbridgeLiftWindowCoveringServer_base: import("@matter/node").
     }];
 }>, readonly [WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift]>, typeof WindowCoveringServer, import("@matter/node/behaviors/window-covering").WindowCoveringInterface>;
 export declare class MatterbridgeLiftWindowCoveringServer extends MatterbridgeLiftWindowCoveringServer_base {
-    upOrOpen(): MaybePromise;
-    downOrClose(): MaybePromise;
-    stopMotion(): MaybePromise;
-    goToLiftPercentage(request: WindowCovering.GoToLiftPercentageRequest): MaybePromise;
+    upOrOpen(): Promise<void>;
+    downOrClose(): Promise<void>;
+    stopMotion(): Promise<void>;
+    goToLiftPercentage(request: WindowCovering.GoToLiftPercentageRequest): Promise<void>;
     handleMovement(type: MovementType, reversed: boolean, direction: MovementDirection, targetPercent100ths?: number): Promise<void>;
 }
 declare const MatterbridgeLiftTiltWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
@@ -1238,20 +1240,20 @@ declare const MatterbridgeLiftTiltWindowCoveringServer_base: import("@matter/nod
     }];
 }>, readonly [WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt]>, typeof WindowCoveringServer, import("@matter/node/behaviors/window-covering").WindowCoveringInterface>;
 export declare class MatterbridgeLiftTiltWindowCoveringServer extends MatterbridgeLiftTiltWindowCoveringServer_base {
-    upOrOpen(): MaybePromise;
-    downOrClose(): MaybePromise;
-    stopMotion(): MaybePromise;
-    goToLiftPercentage(request: WindowCovering.GoToLiftPercentageRequest): MaybePromise;
-    goToTiltPercentage(request: WindowCovering.GoToTiltPercentageRequest): MaybePromise;
+    upOrOpen(): Promise<void>;
+    downOrClose(): Promise<void>;
+    stopMotion(): Promise<void>;
+    goToLiftPercentage(request: WindowCovering.GoToLiftPercentageRequest): Promise<void>;
+    goToTiltPercentage(request: WindowCovering.GoToTiltPercentageRequest): Promise<void>;
     handleMovement(type: MovementType, reversed: boolean, direction: MovementDirection, targetPercent100ths?: number): Promise<void>;
 }
 export declare class MatterbridgeDoorLockServer extends DoorLockServer {
-    lockDoor(): MaybePromise;
-    unlockDoor(): MaybePromise;
+    lockDoor(): Promise<void>;
+    unlockDoor(): Promise<void>;
 }
 declare const MatterbridgeFanControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<FanControl.Cluster, readonly [FanControl.Feature.Auto, FanControl.Feature.Step]>, typeof FanControlServer, import("@matter/node/behaviors/fan-control").FanControlInterface>;
 export declare class MatterbridgeFanControlServer extends MatterbridgeFanControlServer_base {
-    step(request: FanControl.StepRequest): MaybePromise;
+    step(request: FanControl.StepRequest): Promise<void>;
 }
 declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 513;
@@ -1616,7 +1618,7 @@ declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterB
 }>, readonly [Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode]>, typeof ThermostatServer, import("@matter/node/behaviors/thermostat").ThermostatInterface>;
 export declare class MatterbridgeThermostatServer extends MatterbridgeThermostatServer_base {
     initialize(): Promise<void>;
-    setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): MaybePromise;
+    setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): Promise<void>;
 }
 declare const MatterbridgePresetThermostatServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 513;
@@ -1980,13 +1982,13 @@ declare const MatterbridgePresetThermostatServer_base: import("@matter/node").Cl
     }];
 }>, readonly [Thermostat.Feature.Presets, Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode]>, typeof ThermostatServer, import("@matter/node/behaviors/thermostat").ThermostatInterface>;
 export declare class MatterbridgePresetThermostatServer extends MatterbridgePresetThermostatServer_base {
-    setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): MaybePromise;
-    setActivePresetRequest(request: Thermostat.SetActivePresetRequest): MaybePromise;
+    setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): Promise<void>;
+    setActivePresetRequest(request: Thermostat.SetActivePresetRequest): Promise<void>;
 }
 declare const MatterbridgeValveConfigurationAndControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<ValveConfigurationAndControl.Cluster, readonly [ValveConfigurationAndControl.Feature.Level]>, typeof ValveConfigurationAndControlServer, import("@matter/node/behaviors/valve-configuration-and-control").ValveConfigurationAndControlInterface>;
 export declare class MatterbridgeValveConfigurationAndControlServer extends MatterbridgeValveConfigurationAndControlServer_base {
-    open(request: ValveConfigurationAndControl.OpenRequest): MaybePromise;
-    close(): MaybePromise;
+    open(request: ValveConfigurationAndControl.OpenRequest): Promise<void>;
+    close(): Promise<void>;
 }
 declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 92;
@@ -2066,35 +2068,35 @@ declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").Cluste
     }];
 }>, readonly [SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm]>, typeof SmokeCoAlarmServer, import("@matter/node/behaviors/smoke-co-alarm").SmokeCoAlarmInterface>;
 export declare class MatterbridgeSmokeCoAlarmServer extends MatterbridgeSmokeCoAlarmServer_base {
-    selfTestRequest(): MaybePromise;
+    selfTestRequest(): Promise<void>;
 }
 declare const MatterbridgeBooleanStateConfigurationServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<BooleanStateConfiguration.Cluster, readonly [BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel]>, typeof BooleanStateConfigurationServer, import("@matter/node/behaviors/boolean-state-configuration").BooleanStateConfigurationInterface>;
 export declare class MatterbridgeBooleanStateConfigurationServer extends MatterbridgeBooleanStateConfigurationServer_base {
-    enableDisableAlarm(request: BooleanStateConfiguration.EnableDisableAlarmRequest): MaybePromise;
+    enableDisableAlarm(request: BooleanStateConfiguration.EnableDisableAlarmRequest): Promise<void>;
 }
 export declare class MatterbridgeSwitchServer extends SwitchServer {
     initialize(): void;
 }
 export declare class MatterbridgeOperationalStateServer extends OperationalStateServer {
     initialize(): MaybePromise;
-    pause(): MaybePromise<OperationalState.OperationalCommandResponse>;
-    stop(): MaybePromise<OperationalState.OperationalCommandResponse>;
-    start(): MaybePromise<OperationalState.OperationalCommandResponse>;
-    resume(): MaybePromise<OperationalState.OperationalCommandResponse>;
+    pause(): Promise<OperationalState.OperationalCommandResponse>;
+    stop(): Promise<OperationalState.OperationalCommandResponse>;
+    start(): Promise<OperationalState.OperationalCommandResponse>;
+    resume(): Promise<OperationalState.OperationalCommandResponse>;
 }
 export declare class MatterbridgeServiceAreaServer extends ServiceAreaServer {
-    selectAreas(request: ServiceArea.SelectAreasRequest): MaybePromise<ServiceArea.SelectAreasResponse>;
+    selectAreas(request: ServiceArea.SelectAreasRequest): Promise<ServiceArea.SelectAreasResponse>;
 }
 export declare class MatterbridgeModeSelectServer extends ModeSelectServer {
-    changeToMode(request: ModeSelect.ChangeToModeRequest): MaybePromise;
+    changeToMode(request: ModeSelect.ChangeToModeRequest): Promise<void>;
 }
-declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types/clusters/hepa-filter-monitoring").HepaFilterMonitoring.Cluster, readonly [ResourceMonitoring.Feature.Condition]>, typeof HepaFilterMonitoringServer, import("@matter/node/behaviors").ResourceMonitoringInterface>;
+declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<HepaFilterMonitoring.Cluster, readonly [ResourceMonitoring.Feature.Condition]>, typeof HepaFilterMonitoringServer, import("@matter/node/behaviors").ResourceMonitoringInterface>;
 export declare class MatterbridgeHepaFilterMonitoringServer extends MatterbridgeHepaFilterMonitoringServer_base {
-    resetCondition(): MaybePromise;
+    resetCondition(): Promise<void>;
 }
-declare const MatterbridgeActivatedCarbonFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types/clusters/activated-carbon-filter-monitoring").ActivatedCarbonFilterMonitoring.Cluster, readonly [ResourceMonitoring.Feature.Condition]>, typeof ActivatedCarbonFilterMonitoringServer, import("@matter/node/behaviors").ResourceMonitoringInterface>;
+declare const MatterbridgeActivatedCarbonFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<ActivatedCarbonFilterMonitoring.Cluster, readonly [ResourceMonitoring.Feature.Condition]>, typeof ActivatedCarbonFilterMonitoringServer, import("@matter/node/behaviors").ResourceMonitoringInterface>;
 export declare class MatterbridgeActivatedCarbonFilterMonitoringServer extends MatterbridgeActivatedCarbonFilterMonitoringServer_base {
-    resetCondition(): MaybePromise;
+    resetCondition(): Promise<void>;
 }
 declare const MatterbridgeDeviceEnergyManagementServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 152;
@@ -2396,8 +2398,8 @@ declare const MatterbridgeDeviceEnergyManagementServer_base: import("@matter/nod
     }];
 }>, readonly [DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment]>, typeof DeviceEnergyManagementServer, import("@matter/node/behaviors/device-energy-management").DeviceEnergyManagementInterface>;
 export declare class MatterbridgeDeviceEnergyManagementServer extends MatterbridgeDeviceEnergyManagementServer_base {
-    powerAdjustRequest(request: DeviceEnergyManagement.PowerAdjustRequest): MaybePromise;
-    cancelPowerAdjustRequest(): MaybePromise;
+    powerAdjustRequest(request: DeviceEnergyManagement.PowerAdjustRequest): Promise<void>;
+    cancelPowerAdjustRequest(): Promise<void>;
 }
 export declare class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyManagementModeServer {
     changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;