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

package/dist/matterbridgeBehaviorsServer.js

@@ -1,4 +1,3 @@
-import { Bytes } 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,7 +19,6 @@ 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 { WindowCoveringServer } from '@matter/node/behaviors/window-covering';
-import { StatusResponse } from '@matter/types';
 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';
@@ -68,174 +66,312 @@ export class MatterbridgePowerSourceServer extends PowerSourceServer {
     }
 }
 export class MatterbridgeIdentifyServer extends IdentifyServer {
-    identify(request) {
+    async identify(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Identifying device for ${request.identifyTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('identify', { request, cluster: IdentifyServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('Identify.identify', {
+            command: 'identify',
+            request,
+            cluster: IdentifyServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeIdentifyServer: identify called`);
         super.identify(request);
     }
-    triggerEffect(request) {
+    async triggerEffect(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Triggering effect ${request.effectIdentifier} variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('triggerEffect', { request, cluster: IdentifyServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('Identify.triggerEffect', {
+            command: 'triggerEffect',
+            request,
+            cluster: IdentifyServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeIdentifyServer: triggerEffect called`);
         super.triggerEffect(request);
     }
 }
 export class MatterbridgeOnOffServer extends OnOffServer {
-    on() {
+    async on() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('on', { request: {}, cluster: OnOffServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('OnOff.on', {
+            command: 'on',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeOnOffServer: on called`);
         super.on();
     }
-    off() {
+    async off() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('off', { request: {}, cluster: OnOffServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('OnOff.off', {
+            command: 'off',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeOnOffServer: off called`);
         super.off();
     }
-    toggle() {
+    async toggle() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Toggle device on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('toggle', { request: {}, cluster: OnOffServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('OnOff.toggle', {
+            command: 'toggle',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeOnOffServer: toggle called`);
         super.toggle();
     }
 }
 export class MatterbridgeLevelControlServer extends LevelControlServer {
-    moveToLevel(request) {
+    async moveToLevel(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToLevel', { request, cluster: LevelControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('LevelControl.moveToLevel', {
+            command: 'moveToLevel',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeLevelControlServer: moveToLevel called`);
         super.moveToLevel(request);
     }
-    moveToLevelWithOnOff(request) {
+    async moveToLevelWithOnOff(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToLevelWithOnOff', { request, cluster: LevelControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('LevelControl.moveToLevelWithOnOff', {
+            command: 'moveToLevelWithOnOff',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called`);
         super.moveToLevelWithOnOff(request);
     }
 }
 export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
-    moveToHue(request) {
+    async moveToHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting hue to ${request.hue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToHue', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToHue', {
+            command: 'moveToHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToHue called`);
         super.moveToHue(request);
     }
-    moveToSaturation(request) {
+    async moveToSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToSaturation', {
+            command: 'moveToSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called`);
         super.moveToSaturation(request);
     }
-    moveToHueAndSaturation(request) {
+    async moveToHueAndSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting hue to ${request.hue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToHueAndSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToHueAndSaturation', {
+            command: 'moveToHueAndSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToHueAndSaturation called`);
         super.moveToHueAndSaturation(request);
     }
-    moveToColor(request) {
+    async moveToColor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting color to ${request.colorX}, ${request.colorY} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToColor', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToColor', {
+            command: 'moveToColor',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToColor called`);
         super.moveToColor(request);
     }
-    moveToColorTemperature(request) {
+    async moveToColorTemperature(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting color temperature to ${request.colorTemperatureMireds} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToColorTemperature', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToColorTemperature', {
+            command: 'moveToColorTemperature',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called`);
         super.moveToColorTemperature(request);
     }
 }
 export class MatterbridgeEnhancedColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
-    moveToHue(request) {
+    async moveToHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting hue to ${request.hue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToHue', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToHue', {
+            command: 'moveToHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToHue called`);
         super.moveToHue(request);
     }
-    enhancedMoveToHue(request) {
+    async enhancedMoveToHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting enhanced hue to ${request.enhancedHue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('enhancedMoveToHue', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.enhancedMoveToHue', {
+            command: 'enhancedMoveToHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHue called`);
         super.enhancedMoveToHue(request);
     }
-    moveToSaturation(request) {
+    async moveToSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToSaturation', {
+            command: 'moveToSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called`);
         super.moveToSaturation(request);
     }
-    moveToHueAndSaturation(request) {
+    async moveToHueAndSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting hue to ${request.hue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToHueAndSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToHueAndSaturation', {
+            command: 'moveToHueAndSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToHueAndSaturation called`);
         super.moveToHueAndSaturation(request);
     }
-    enhancedMoveToHueAndSaturation(request) {
+    async enhancedMoveToHueAndSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting enhanced hue to ${request.enhancedHue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('enhancedMoveToHueAndSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.enhancedMoveToHueAndSaturation', {
+            command: 'enhancedMoveToHueAndSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHueAndSaturation called`);
         super.enhancedMoveToHueAndSaturation(request);
     }
-    moveToColor(request) {
+    async moveToColor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting color to ${request.colorX}, ${request.colorY} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToColor', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToColor', {
+            command: 'moveToColor',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToColor called`);
         super.moveToColor(request);
     }
-    moveToColorTemperature(request) {
+    async moveToColorTemperature(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting color temperature to ${request.colorTemperatureMireds} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveToColorTemperature', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ColorControl.moveToColorTemperature', {
+            command: 'moveToColorTemperature',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called`);
         super.moveToColorTemperature(request);
     }
 }
 export class MatterbridgeLiftWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift) {
-    upOrOpen() {
+    async upOrOpen() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Opening cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler(`upOrOpen`, { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.upOrOpen', {
+            command: 'upOrOpen',
+            request: {},
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen called`);
         super.upOrOpen();
     }
-    downOrClose() {
+    async downOrClose() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Closing cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler(`downOrClose`, { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.downOrClose', {
+            command: 'downOrClose',
+            request: {},
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose called`);
         super.downOrClose();
     }
-    stopMotion() {
+    async stopMotion() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stopping cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('stopMotion', { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.stopMotion', {
+            command: 'stopMotion',
+            request: {},
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion called`);
         super.stopMotion();
     }
-    goToLiftPercentage(request) {
+    async goToLiftPercentage(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting cover lift percentage to ${request.liftPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('goToLiftPercentage', { request, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.goToLiftPercentage', {
+            command: 'goToLiftPercentage',
+            request,
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage with ${request.liftPercent100thsValue}`);
         super.goToLiftPercentage(request);
     }
@@ -243,38 +379,68 @@ export class MatterbridgeLiftWindowCoveringServer extends WindowCoveringServer.w
     }
 }
 export class MatterbridgeLiftTiltWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt) {
-    upOrOpen() {
+    async upOrOpen() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Opening cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler(`upOrOpen`, { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.upOrOpen', {
+            command: 'upOrOpen',
+            request: {},
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: upOrOpen called`);
         super.upOrOpen();
     }
-    downOrClose() {
+    async downOrClose() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Closing cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler(`downOrClose`, { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.downOrClose', {
+            command: 'downOrClose',
+            request: {},
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: downOrClose called`);
         super.downOrClose();
     }
-    stopMotion() {
+    async stopMotion() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stopping cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('stopMotion', { request: {}, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.stopMotion', {
+            command: 'stopMotion',
+            request: {},
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: stopMotion called`);
         super.stopMotion();
     }
-    goToLiftPercentage(request) {
+    async goToLiftPercentage(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting cover lift percentage to ${request.liftPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('goToLiftPercentage', { request, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.goToLiftPercentage', {
+            command: 'goToLiftPercentage',
+            request,
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: goToLiftPercentage with ${request.liftPercent100thsValue}`);
         super.goToLiftPercentage(request);
     }
-    goToTiltPercentage(request) {
+    async goToTiltPercentage(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting cover tilt percentage to ${request.tiltPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('goToTiltPercentage', { request, cluster: WindowCoveringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('WindowCovering.goToTiltPercentage', {
+            command: 'goToTiltPercentage',
+            request,
+            cluster: WindowCoveringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeLiftTiltWindowCoveringServer: goToTiltPercentage with ${request.tiltPercent100thsValue}`);
         super.goToTiltPercentage(request);
     }
@@ -282,26 +448,44 @@ export class MatterbridgeLiftTiltWindowCoveringServer extends WindowCoveringServ
     }
 }
 export class MatterbridgeDoorLockServer extends DoorLockServer {
-    lockDoor() {
+    async lockDoor() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Locking door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('lockDoor', { request: {}, cluster: DoorLockServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('DoorLock.lockDoor', {
+            command: 'lockDoor',
+            request: {},
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeDoorLockServer: lockDoor called`);
         super.lockDoor();
     }
-    unlockDoor() {
+    async unlockDoor() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Unlocking door (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('unlockDoor', { request: {}, cluster: DoorLockServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('DoorLock.unlockDoor', {
+            command: 'unlockDoor',
+            request: {},
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called`);
         super.unlockDoor();
     }
 }
 export class MatterbridgeFanControlServer extends FanControlServer.with(FanControl.Feature.Auto, FanControl.Feature.Step) {
-    step(request) {
+    async step(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stepping fan with direction ${request.direction} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('step', { request, cluster: FanControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('FanControl.step', {
+            command: 'step',
+            request,
+            cluster: FanControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const lookupStepDirection = ['Increase', 'Decrease'];
         device.log.debug(`MatterbridgeFanControlServer: step called with direction: ${lookupStepDirection[request.direction]} wrap: ${request.wrap} lowestOff: ${request.lowestOff}`);
         device.log.debug(`- current percentCurrent: ${this.state.percentCurrent}`);
@@ -334,68 +518,64 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
             });
         });
     }
-    setpointRaiseLower(request) {
+    async setpointRaiseLower(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('setpointRaiseLower', { request, cluster: ThermostatServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('Thermostat.setpointRaiseLower', {
+            command: 'setpointRaiseLower',
+            request,
+            cluster: ThermostatServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
         device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10}`);
-        if (this.state.occupiedHeatingSetpoint !== undefined)
-            device.log.debug(`- current occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint / 100}`);
-        if (this.state.occupiedCoolingSetpoint !== undefined)
-            device.log.debug(`- current occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint / 100}`);
-        if ((request.mode === Thermostat.SetpointRaiseLowerMode.Heat || request.mode === Thermostat.SetpointRaiseLowerMode.Both) && this.state.occupiedHeatingSetpoint !== undefined) {
-            const setpoint = this.state.occupiedHeatingSetpoint / 100 + request.amount / 10;
-            this.state.occupiedHeatingSetpoint = setpoint * 100;
-            device.log.debug(`Set occupiedHeatingSetpoint to ${setpoint}`);
-        }
-        if ((request.mode === Thermostat.SetpointRaiseLowerMode.Cool || request.mode === Thermostat.SetpointRaiseLowerMode.Both) && this.state.occupiedCoolingSetpoint !== undefined) {
-            const setpoint = this.state.occupiedCoolingSetpoint / 100 + request.amount / 10;
-            this.state.occupiedCoolingSetpoint = setpoint * 100;
-            device.log.debug(`Set occupiedCoolingSetpoint to ${setpoint}`);
-        }
+        await super.setpointRaiseLower(request);
     }
 }
 export class MatterbridgePresetThermostatServer extends ThermostatServer.with(Thermostat.Feature.Presets, Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
-    setpointRaiseLower(request) {
+    async setpointRaiseLower(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('setpointRaiseLower', { request, cluster: ThermostatServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('Thermostat.setpointRaiseLower', {
+            command: 'setpointRaiseLower',
+            request,
+            cluster: ThermostatServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
-        device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10}`);
-        if (this.state.occupiedHeatingSetpoint !== undefined)
-            device.log.debug(`- current occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint / 100}`);
-        if (this.state.occupiedCoolingSetpoint !== undefined)
-            device.log.debug(`- current occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint / 100}`);
-        if ((request.mode === Thermostat.SetpointRaiseLowerMode.Heat || request.mode === Thermostat.SetpointRaiseLowerMode.Both) && this.state.occupiedHeatingSetpoint !== undefined) {
-            const setpoint = this.state.occupiedHeatingSetpoint / 100 + request.amount / 10;
-            this.state.occupiedHeatingSetpoint = setpoint * 100;
-            device.log.debug(`Set occupiedHeatingSetpoint to ${setpoint}`);
-        }
-        if ((request.mode === Thermostat.SetpointRaiseLowerMode.Cool || request.mode === Thermostat.SetpointRaiseLowerMode.Both) && this.state.occupiedCoolingSetpoint !== undefined) {
-            const setpoint = this.state.occupiedCoolingSetpoint / 100 + request.amount / 10;
-            this.state.occupiedCoolingSetpoint = setpoint * 100;
-            device.log.debug(`Set occupiedCoolingSetpoint to ${setpoint}`);
-        }
-    }
-    setActivePresetRequest(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting preset to ${request.presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('setActivePresetRequest', { request, cluster: ThermostatServer.id, attributes: this.state, endpoint: this.endpoint });
-        if (request.presetHandle !== null) {
-            const preset = this.state.persistedPresets?.find((storedPreset) => storedPreset.presetHandle !== null && Bytes.areEqual(storedPreset.presetHandle, request.presetHandle));
-            if (preset === undefined)
-                throw new StatusResponse.InvalidCommandError('Requested PresetHandle not found');
-        }
-        this.state.activePresetHandle = request.presetHandle;
-        device.log.debug(`MatterbridgePresetThermostatServer: setActivePresetRequest called with presetHandle: ${request.presetHandle}`);
+        device.log.debug(`MatterbridgePresetThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10}`);
+        await super.setpointRaiseLower(request);
+    }
+    async setActivePresetRequest(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const presetHandle = request.presetHandle ? `0x${Buffer.from(request.presetHandle).toString('hex')}` : 'null';
+        device.log.info(`Setting preset to ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('Thermostat.setActivePresetRequest', {
+            command: 'setActivePresetRequest',
+            request,
+            cluster: ThermostatServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        device.log.debug(`MatterbridgePresetThermostatServer: setActivePresetRequest called with presetHandle: ${presetHandle}`);
+        await super.setActivePresetRequest(request);
+        const activePresetHandle = this.state.activePresetHandle ? `0x${Buffer.from(this.state.activePresetHandle).toString('hex')}` : 'null';
+        device.log.debug(`MatterbridgePresetThermostatServer: setActivePresetRequest completed with activePresetHandle: ${activePresetHandle} occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint} occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint}`);
     }
 }
 export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigurationAndControlServer.with(ValveConfigurationAndControl.Feature.Level) {
-    open(request) {
+    async open(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Opening valve to ${request.targetLevel ? request.targetLevel + '%' : 'fully opened'} ${request.openDuration ? 'for ' + request.openDuration + 's' : 'until closed'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('open', { request, cluster: ValveConfigurationAndControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ValveConfigurationAndControl.open', {
+            command: 'open',
+            request,
+            cluster: ValveConfigurationAndControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${request.openDuration} targetLevel: ${request.targetLevel}`);
         this.state.targetState = ValveConfigurationAndControl.ValveState.Open;
         this.state.currentState = ValveConfigurationAndControl.ValveState.Open;
@@ -405,10 +585,16 @@ export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigu
         if (this.state.openDuration === null)
             this.state.remainingDuration = null;
     }
-    close() {
+    async close() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Closing valve (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('close', { request: {}, cluster: ValveConfigurationAndControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ValveConfigurationAndControl.close', {
+            command: 'close',
+            request: {},
+            cluster: ValveConfigurationAndControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called`);
         this.state.targetState = ValveConfigurationAndControl.ValveState.Closed;
         this.state.currentState = ValveConfigurationAndControl.ValveState.Closed;
@@ -419,18 +605,30 @@ export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigu
     }
 }
 export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm) {
-    selfTestRequest() {
+    async selfTestRequest() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Testing SmokeCOAlarm (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('selfTestRequest', { request: {}, cluster: SmokeCoAlarmServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('SmokeCoAlarm.selfTestRequest', {
+            command: 'selfTestRequest',
+            request: {},
+            cluster: SmokeCoAlarmServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called`);
     }
 }
 export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
-    enableDisableAlarm(request) {
+    async enableDisableAlarm(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Enabling/disabling alarm ${request.alarmsToEnableDisable} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('enableDisableAlarm', { request, cluster: BooleanStateConfigurationServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('BooleanStateConfiguration.enableDisableAlarm', {
+            command: 'enableDisableAlarm',
+            request,
+            cluster: BooleanStateConfigurationServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called`);
     }
 }
@@ -446,10 +644,16 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         super.initialize();
     }
-    pause() {
+    async pause() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Pause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('pause', { request: {}, cluster: OperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('OperationalState.pause', {
+            command: 'pause',
+            request: {},
+            cluster: OperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug('MatterbridgeOperationalStateServer: pause called setting operational state to Paused');
         this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
@@ -457,10 +661,16 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
     }
-    stop() {
+    async stop() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('stop', { request: {}, cluster: OperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('OperationalState.stop', {
+            command: 'stop',
+            request: {},
+            cluster: OperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped');
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
@@ -468,10 +678,16 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
     }
-    start() {
+    async start() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Start (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('start', { request: {}, cluster: OperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('OperationalState.start', {
+            command: 'start',
+            request: {},
+            cluster: OperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug('MatterbridgeOperationalStateServer: start called setting operational state to Running');
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
@@ -479,10 +695,16 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
     }
-    resume() {
+    async resume() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Resume (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('resume', { request: {}, cluster: OperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('OperationalState.resume', {
+            command: 'resume',
+            request: {},
+            cluster: OperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug('MatterbridgeOperationalStateServer: resume called setting operational state to Running');
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
@@ -492,10 +714,16 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
     }
 }
 export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
-    selectAreas(request) {
+    async selectAreas(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Selecting areas ${request.newAreas} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('selectAreas', { request, cluster: ServiceAreaServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ServiceArea.selectAreas', {
+            command: 'selectAreas',
+            request,
+            cluster: ServiceAreaServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         for (const area of request.newAreas) {
             const supportedArea = this.state.supportedAreas.find((supportedArea) => supportedArea.areaId === area);
             if (!supportedArea) {
@@ -505,49 +733,79 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
         }
         this.state.selectedAreas = request.newAreas;
         device.log.debug(`MatterbridgeServiceAreaServer selectAreas called with: ${request.newAreas.map((area) => area.toString()).join(', ')}`);
-        return super.selectAreas(request);
+        return await super.selectAreas(request);
     }
 }
 export class MatterbridgeModeSelectServer extends ModeSelectServer {
-    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: ModeSelectServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ModeSelect.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: ModeSelectServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeModeSelectServer: changeToMode called with mode: ${request.newMode}`);
         super.changeToMode(request);
     }
 }
 export class MatterbridgeHepaFilterMonitoringServer extends HepaFilterMonitoringServer.with(ResourceMonitoring.Feature.Condition) {
-    resetCondition() {
+    async resetCondition() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Resetting condition (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('resetCondition', { cluster: MatterbridgeHepaFilterMonitoringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('HepaFilterMonitoring.resetCondition', {
+            command: 'resetCondition',
+            request: {},
+            cluster: MatterbridgeHepaFilterMonitoringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         this.state.condition = 100;
         this.state.lastChangedTime = Math.floor(new Date().getTime() / 1000);
         device.log.debug(`MatterbridgeHepaFilterMonitoringServer: resetCondition called`);
     }
 }
 export class MatterbridgeActivatedCarbonFilterMonitoringServer extends ActivatedCarbonFilterMonitoringServer.with(ResourceMonitoring.Feature.Condition) {
-    resetCondition() {
+    async resetCondition() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Resetting condition (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('resetCondition', { cluster: MatterbridgeActivatedCarbonFilterMonitoringServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ActivatedCarbonFilterMonitoring.resetCondition', {
+            command: 'resetCondition',
+            request: {},
+            cluster: MatterbridgeActivatedCarbonFilterMonitoringServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         this.state.condition = 100;
         this.state.lastChangedTime = Math.floor(new Date().getTime() / 1000);
         device.log.debug(`MatterbridgeActivatedCarbonFilterMonitoringServer: resetCondition called`);
     }
 }
 export class MatterbridgeDeviceEnergyManagementServer extends DeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment) {
-    powerAdjustRequest(request) {
+    async powerAdjustRequest(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Adjusting power to ${request.power} duration ${request.duration} cause ${request.cause} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('powerAdjustRequest', { request, cluster: DeviceEnergyManagementServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('DeviceEnergyManagement.powerAdjustRequest', {
+            command: 'powerAdjustRequest',
+            request,
+            cluster: DeviceEnergyManagementServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeDeviceEnergyManagementServer powerAdjustRequest called with power ${request.power} duration ${request.duration} cause ${request.cause}`);
     }
-    cancelPowerAdjustRequest() {
+    async cancelPowerAdjustRequest() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Cancelling power adjustment (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('cancelPowerAdjustRequest', { cluster: DeviceEnergyManagementServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('DeviceEnergyManagement.cancelPowerAdjustRequest', {
+            command: 'cancelPowerAdjustRequest',
+            request: {},
+            cluster: DeviceEnergyManagementServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeDeviceEnergyManagementServer cancelPowerAdjustRequest called`);
     }
 }
@@ -555,7 +813,13 @@ export class MatterbridgeDeviceEnergyManagementModeServer extends DeviceEnergyMa
     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: DeviceEnergyManagementModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('DeviceEnergyManagementMode.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: DeviceEnergyManagementModeServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
             device.log.error(`MatterbridgeDeviceEnergyManagementModeServer changeToMode called with unsupported newMode: ${request.newMode}`);