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

package/dist/devices/basicVideoPlayer.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { KeypadInputServer } from '@matter/node/behaviors/keypad-input';
 import { MediaPlaybackServer } from '@matter/node/behaviors/media-playback';
 import { KeypadInput } from '@matter/types/clusters/keypad-input';
@@ -16,15 +15,15 @@ export declare class BasicVideoPlayer extends MatterbridgeEndpoint {
 export declare class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
     initialize(): void;
     protected handleOnOffChange(_onOff: boolean): void;
-    play(): MaybePromise<MediaPlayback.PlaybackResponse>;
-    pause(): MaybePromise<MediaPlayback.PlaybackResponse>;
-    stop(): MaybePromise<MediaPlayback.PlaybackResponse>;
-    previous(): MaybePromise<MediaPlayback.PlaybackResponse>;
-    next(): MaybePromise<MediaPlayback.PlaybackResponse>;
-    skipForward(): MaybePromise<MediaPlayback.PlaybackResponse>;
-    skipBackward(): MaybePromise<MediaPlayback.PlaybackResponse>;
+    play(): Promise<MediaPlayback.PlaybackResponse>;
+    pause(): Promise<MediaPlayback.PlaybackResponse>;
+    stop(): Promise<MediaPlayback.PlaybackResponse>;
+    previous(): Promise<MediaPlayback.PlaybackResponse>;
+    next(): Promise<MediaPlayback.PlaybackResponse>;
+    skipForward(request: MediaPlayback.SkipForwardRequest): Promise<MediaPlayback.PlaybackResponse>;
+    skipBackward(request: MediaPlayback.SkipBackwardRequest): Promise<MediaPlayback.PlaybackResponse>;
 }
 export declare class MatterbridgeKeypadInputServer extends KeypadInputServer {
     initialize(): void;
-    sendKey(request: KeypadInput.SendKeyRequest): MaybePromise<KeypadInput.SendKeyResponse>;
+    sendKey(request: KeypadInput.SendKeyRequest): Promise<KeypadInput.SendKeyResponse>;
 }

package/dist/devices/basicVideoPlayer.js

@@ -37,52 +37,94 @@ export class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
     handleOnOffChange(_onOff) {
         this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
     }
-    play() {
+    async play() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Play (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('play', { request: undefined, cluster: MediaPlaybackServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('MediaPlayback.play', {
+            command: 'play',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff === true)
             this.state.currentState = MediaPlayback.PlaybackState.Playing;
         return { status: MediaPlayback.Status.Success };
     }
-    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: undefined, cluster: MediaPlaybackServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('MediaPlayback.pause', {
+            command: 'pause',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff === true)
             this.state.currentState = MediaPlayback.PlaybackState.Paused;
         return { status: MediaPlayback.Status.Success };
     }
-    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: undefined, cluster: MediaPlaybackServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('MediaPlayback.stop', {
+            command: 'stop',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff === true)
             this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
         return { status: MediaPlayback.Status.Success };
     }
-    previous() {
+    async previous() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Previous (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('previous', { request: undefined, cluster: MediaPlaybackServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('MediaPlayback.previous', {
+            command: 'previous',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         return { status: MediaPlayback.Status.Success };
     }
-    next() {
+    async next() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Next (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('next', { request: undefined, cluster: MediaPlaybackServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('MediaPlayback.next', {
+            command: 'next',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         return { status: MediaPlayback.Status.Success };
     }
-    skipForward() {
+    async skipForward(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`SkipForward (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('skipForward', { request: undefined, cluster: MediaPlaybackServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('MediaPlayback.skipForward', {
+            command: 'skipForward',
+            request,
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         return { status: MediaPlayback.Status.Success };
     }
-    skipBackward() {
+    async skipBackward(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`SkipBackward (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('skipBackward', { request: undefined, cluster: MediaPlaybackServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('MediaPlayback.skipBackward', {
+            command: 'skipBackward',
+            request,
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         return { status: MediaPlayback.Status.Success };
     }
 }
@@ -91,10 +133,16 @@ export class MatterbridgeKeypadInputServer extends KeypadInputServer {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeKeypadInputServer initialized`);
     }
-    sendKey(request) {
+    async sendKey(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`SendKey keyCode ${request.keyCode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('sendKey', { request, cluster: KeypadInputServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('KeypadInput.sendKey', {
+            command: 'sendKey',
+            request,
+            cluster: KeypadInputServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         return { status: KeypadInput.Status.Success };
     }
 }

package/dist/devices/closure.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { ClusterBehavior } from '@matter/node';
 import { ClusterType } from '@matter/types';
 import { ClosureControl } from '../clusters/closure-control.js';
@@ -291,8 +290,8 @@ declare const ClosureControlServer_base: ClusterBehavior.Type<import("@matter/ty
 }>;
 export declare class ClosureControlServer extends ClosureControlServer_base {
     state: ClosureControlServer.State;
-    moveTo: (request: ClosureControl.MoveToRequest) => MaybePromise;
-    stop: () => MaybePromise;
+    moveTo: (request: ClosureControl.MoveToRequest) => Promise<void>;
+    stop: () => Promise<void>;
 }
 export interface ClosureOptions {
     mainState?: ClosureControl.MainState;

package/dist/devices/closure.js

@@ -12,10 +12,16 @@ const ClosureControlSchema = ClusterElement({
 }, AttributeElement({ id: 0xfffd, name: 'ClusterRevision', type: 'ClusterRevision', conformance: 'M', default: ClosureControl.Base.revision }), AttributeElement({ id: 0xfffc, name: 'FeatureMap', type: 'FeatureMap', conformance: 'M' }, FieldElement({ name: 'POS', constraint: '0', title: 'Positioning' }), FieldElement({ name: 'ML', constraint: '1', title: 'MotionLatching' }), FieldElement({ name: 'INS', constraint: '2', title: 'Instantaneous' }), FieldElement({ name: 'SPD', constraint: '3', title: 'Speed' }), FieldElement({ name: 'VNT', constraint: '4', title: 'Ventilation' }), FieldElement({ name: 'PED', constraint: '5', title: 'Pedestrian' }), FieldElement({ name: 'CAL', constraint: '6', title: 'Calibration' }), FieldElement({ name: 'PRT', constraint: '7', title: 'Protection' }), FieldElement({ name: 'MAN', constraint: '8', title: 'ManuallyOperable' })), AttributeElement({ name: 'CountdownTime', id: 0x0000, type: 'uint32', conformance: 'POS', default: null, quality: 'X' }), AttributeElement({ name: 'MainState', id: 0x0001, type: 'MainStateEnum', conformance: 'M', constraint: 'desc' }), AttributeElement({ name: 'CurrentErrorList', id: 0x0002, type: 'list', conformance: 'M', default: [] }, FieldElement({ name: 'entry', type: 'ClosureErrorEnum' })), AttributeElement({ name: 'OverallCurrentState', id: 0x0003, type: 'OverallCurrentStateStruct', conformance: 'M', default: null, quality: 'X' }), AttributeElement({ name: 'OverallTargetState', id: 0x0004, type: 'OverallTargetStateStruct', conformance: 'M', default: null, quality: 'X' }), CommandElement({ name: 'Stop', id: 0x0000, conformance: 'M', direction: 'request', response: 'status' }), CommandElement({ name: 'MoveTo', id: 0x0001, conformance: 'M', direction: 'request', response: 'status' }, FieldElement({ name: 'Position', id: 0, type: 'TargetPositionEnum', conformance: 'O' }), FieldElement({ name: 'Latch', id: 1, type: 'bool', conformance: 'O' }), FieldElement({ name: 'Speed', id: 2, type: 'ThreeLevelAutoEnum', conformance: 'O' })), EventElement({ name: 'OperationalError', id: 0x0000, conformance: 'M', priority: 'critical' }, FieldElement({ name: 'ErrorState', id: 0, type: 'list', conformance: 'M', constraint: 'max 10' }, FieldElement({ name: 'entry', type: 'ClosureErrorEnum' }))), EventElement({ name: 'MovementCompleted', id: 0x0001, conformance: 'M', priority: 'info' }), EventElement({ name: 'SecureStateChanged', id: 0x0003, conformance: 'M', priority: 'info' }, FieldElement({ name: 'SecureValue', id: 0, type: 'bool', conformance: 'M' })), DatatypeElement({ name: 'ClosureErrorEnum', type: 'enum8' }, FieldElement({ name: 'PhysicallyBlocked', id: 0, conformance: 'M' }), FieldElement({ name: 'BlockedBySensor', id: 1, conformance: 'M' }), FieldElement({ name: 'TemperatureLimited', id: 2, conformance: 'M' }), FieldElement({ name: 'MaintenanceRequired', id: 3, conformance: 'M' }), FieldElement({ name: 'InternalInterference', id: 4, conformance: 'M' })), DatatypeElement({ name: 'CurrentPositionEnum', type: 'enum8' }, FieldElement({ name: 'FullyClosed', id: 0, conformance: 'M' }), FieldElement({ name: 'FullyOpened', id: 1, conformance: 'M' }), FieldElement({ name: 'PartiallyOpened', id: 2, conformance: 'M' }), FieldElement({ name: 'OpenedForPedestrian', id: 3, conformance: 'M' }), FieldElement({ name: 'OpenedForVentilation', id: 4, conformance: 'M' }), FieldElement({ name: 'OpenedAtSignature', id: 5, conformance: 'M' })), DatatypeElement({ name: 'MainStateEnum', type: 'enum8' }, FieldElement({ name: 'Stopped', id: 0, conformance: 'M' }), FieldElement({ name: 'Moving', id: 1, conformance: 'M' }), FieldElement({ name: 'WaitingForMotion', id: 2, conformance: 'M' }), FieldElement({ name: 'Error', id: 3, conformance: 'M' }), FieldElement({ name: 'Calibrating', id: 4, conformance: 'M' }), FieldElement({ name: 'Protected', id: 5, conformance: 'M' }), FieldElement({ name: 'Disengaged', id: 6, conformance: 'M' }), FieldElement({ name: 'SetupRequired', id: 7, conformance: 'M' })), DatatypeElement({ name: 'TargetPositionEnum', type: 'enum8' }, FieldElement({ name: 'MoveToFullyClosed', id: 0, conformance: 'M' }), FieldElement({ name: 'MoveToFullyOpen', id: 1, conformance: 'M' }), FieldElement({ name: 'MoveToPedestrianPosition', id: 2, conformance: 'M' }), FieldElement({ name: 'MoveToVentilationPosition', id: 3, conformance: 'M' }), FieldElement({ name: 'MoveToSignaturePosition', id: 4, conformance: 'M' })), DatatypeElement({ name: 'OverallCurrentStateStruct', type: 'struct' }, FieldElement({ name: 'Position', id: 0, type: 'CurrentPositionEnum', conformance: 'O', default: null, quality: 'X' }), FieldElement({ name: 'Latch', id: 1, type: 'bool', conformance: 'O', default: null, quality: 'X' }), FieldElement({ name: 'Speed', id: 2, type: 'ThreeLevelAutoEnum', conformance: 'O' }), FieldElement({ name: 'SecureState', id: 3, type: 'bool', conformance: 'O', default: null, quality: 'X' })), DatatypeElement({ name: 'OverallTargetStateStruct', type: 'struct' }, FieldElement({ name: 'Position', id: 0, type: 'TargetPositionEnum', conformance: 'O', default: null, quality: 'X' }), FieldElement({ name: 'Latch', id: 1, type: 'bool', conformance: 'O', default: null, quality: 'X' }), FieldElement({ name: 'Speed', id: 2, type: 'ThreeLevelAutoEnum', conformance: 'O' })));
 const ClosureControlBehavior = ClusterBehavior.for(ClusterType(ClosureControl.Base), new ClusterModel(ClosureControlSchema));
 export class ClosureControlServer extends ClosureControlBehavior.with(ClosureControl.Feature.Positioning) {
-    moveTo = (request) => {
+    moveTo = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MoveTo (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('moveTo', { request, cluster: ClosureControl.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ClosureControl.moveTo', {
+            command: 'moveTo',
+            request,
+            cluster: ClosureControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const previousTarget = this.state.overallTargetState ?? {};
         const nextTarget = {
             ...previousTarget,
@@ -26,10 +32,16 @@ export class ClosureControlServer extends ClosureControlBehavior.with(ClosureCon
         this.state.overallTargetState = nextTarget;
         this.state.mainState = ClosureControl.MainState.Moving;
     };
-    stop = () => {
+    stop = async () => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('stop', { request: {}, cluster: ClosureControl.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ClosureControl.stop', {
+            command: 'stop',
+            request: {},
+            cluster: ClosureControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         this.state.mainState = ClosureControl.MainState.Stopped;
     };
 }

package/dist/devices/closurePanel.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { ClusterBehavior } from '@matter/node';
 import { ClusterType } from '@matter/types';
 import { ClosureDimension } from '../clusters/closure-dimension.js';
@@ -370,8 +369,8 @@ declare const ClosureDimensionServer_base: ClusterBehavior.Type<import("@matter/
 }>;
 export declare class ClosureDimensionServer extends ClosureDimensionServer_base {
     state: ClosureDimensionServer.State;
-    setTarget: (request: ClosureDimension.SetTargetRequest) => MaybePromise;
-    step: (request: ClosureDimension.StepRequest) => MaybePromise;
+    setTarget: (request: ClosureDimension.SetTargetRequest) => Promise<void>;
+    step: (request: ClosureDimension.StepRequest) => Promise<void>;
 }
 export interface ClosurePanelOptions {
     resolution?: number;

package/dist/devices/closurePanel.js

@@ -12,10 +12,16 @@ const ClosureDimensionSchema = ClusterElement({
 }, AttributeElement({ id: 0xfffd, name: 'ClusterRevision', type: 'ClusterRevision', conformance: 'M', default: ClosureDimension.Base.revision }), AttributeElement({ id: 0xfffc, name: 'FeatureMap', type: 'FeatureMap', conformance: 'M' }, FieldElement({ name: 'POS', constraint: '0', title: 'Positioning' }), FieldElement({ name: 'ML', constraint: '1', title: 'MotionLatching' }), FieldElement({ name: 'UNI', constraint: '2', title: 'Unit' }), FieldElement({ name: 'LIM', constraint: '3', title: 'Limitation' }), FieldElement({ name: 'SPD', constraint: '4', title: 'Speed' }), FieldElement({ name: 'TRN', constraint: '5', title: 'Translation' }), FieldElement({ name: 'ROT', constraint: '6', title: 'Rotation' }), FieldElement({ name: 'MOD', constraint: '7', title: 'Modulation' })), AttributeElement({ name: 'CurrentState', id: 0x0000, type: 'DimensionStateStruct', conformance: 'M', default: null, quality: 'X' }), AttributeElement({ name: 'TargetState', id: 0x0001, type: 'DimensionStateStruct', conformance: 'M', default: null, quality: 'X' }), AttributeElement({ name: 'Resolution', id: 0x0002, type: 'percent100ths', conformance: 'POS', default: 1 }), AttributeElement({ name: 'StepValue', id: 0x0003, type: 'percent100ths', conformance: 'POS', default: 1 }), CommandElement({ name: 'SetTarget', id: 0x0000, conformance: 'M', direction: 'request', response: 'status' }, FieldElement({ name: 'Position', id: 0, type: 'percent100ths', conformance: 'O' }), FieldElement({ name: 'Latch', id: 1, type: 'bool', conformance: 'O' }), FieldElement({ name: 'Speed', id: 2, type: 'ThreeLevelAutoEnum', conformance: 'O' })), CommandElement({ name: 'Step', id: 0x0001, conformance: 'POS', direction: 'request', response: 'status' }, FieldElement({ name: 'Direction', id: 0, type: 'StepDirectionEnum', conformance: 'M' }), FieldElement({ name: 'NumberOfSteps', id: 1, type: 'uint16', conformance: 'M', constraint: { min: 1 } }), FieldElement({ name: 'Speed', id: 2, type: 'ThreeLevelAutoEnum', conformance: 'O' })), DatatypeElement({ name: 'StepDirectionEnum', type: 'enum8' }, FieldElement({ name: 'Decrease', id: 0, conformance: 'M' }), FieldElement({ name: 'Increase', id: 1, conformance: 'M' })), DatatypeElement({ name: 'DimensionStateStruct', type: 'struct' }, FieldElement({ name: 'Position', id: 0, type: 'percent100ths', conformance: 'O', default: null, quality: 'X' }), FieldElement({ name: 'Latch', id: 1, type: 'bool', conformance: 'O', default: null, quality: 'X' }), FieldElement({ name: 'Speed', id: 2, type: 'ThreeLevelAutoEnum', conformance: 'O' })));
 const ClosureDimensionBehavior = ClusterBehavior.for(ClusterType(ClosureDimension.Base), new ClusterModel(ClosureDimensionSchema));
 export class ClosureDimensionServer extends ClosureDimensionBehavior.with(ClosureDimension.Feature.Positioning) {
-    setTarget = (request) => {
+    setTarget = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`SetTarget (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('setTarget', { request, cluster: ClosureDimension.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ClosureDimension.setTarget', {
+            command: 'setTarget',
+            request,
+            cluster: ClosureDimensionServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const previousTarget = this.state.targetState ?? {};
         const nextTarget = {
             ...previousTarget,
@@ -25,10 +31,16 @@ export class ClosureDimensionServer extends ClosureDimensionBehavior.with(Closur
         };
         this.state.targetState = nextTarget;
     };
-    step = (request) => {
+    step = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Step (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('step', { request, cluster: ClosureDimension.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('ClosureDimension.step', {
+            command: 'step',
+            request,
+            cluster: ClosureDimensionServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const stepValue = this.state.stepValue;
         const numberOfSteps = request.numberOfSteps;
         const delta = stepValue * numberOfSteps;

package/dist/devices/dishwasher.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
@@ -12,5 +11,5 @@ export declare class Dishwasher extends MatterbridgeEndpoint {
 export declare class MatterbridgeDishwasherModeServer extends DishwasherModeServer {
     initialize(): void;
     protected handleOnOffChange(onOff: boolean): void;
-    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+    changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }

package/dist/devices/dishwasher.js

@@ -55,10 +55,16 @@ export class MatterbridgeDishwasherModeServer extends DishwasherModeServer {
             this.state.currentMode = 2;
         }
     }
-    changeToMode(request) {
+    async changeToMode(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`ChangeToMode (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('changeToMode', { request, cluster: DishwasherModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('DishwasherMode.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: DishwasherModeServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
         if (supportedMode) {
             device.log.info(`DishwasherModeServer: changeToMode called with mode ${supportedMode.mode} => ${supportedMode.label}`);

package/dist/devices/evse.d.ts

@@ -12,13 +12,13 @@ export declare class Evse extends MatterbridgeEndpoint {
 }
 declare const MatterbridgeEnergyEvseServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<EnergyEvse.Cluster, readonly [EnergyEvse.Feature.ChargingPreferences]>, typeof EnergyEvseServer, import("@matter/node/behaviors/energy-evse").EnergyEvseInterface>;
 export declare class MatterbridgeEnergyEvseServer extends MatterbridgeEnergyEvseServer_base {
-    disable(): MaybePromise;
-    enableCharging(request: EnergyEvse.EnableChargingRequest): MaybePromise;
+    disable(): Promise<void>;
+    enableCharging(request: EnergyEvse.EnableChargingRequest): Promise<void>;
     setTargets(request: EnergyEvse.SetTargetsRequest): MaybePromise;
     getTargets(): MaybePromise<EnergyEvse.GetTargetsResponse>;
     clearTargets(): MaybePromise;
 }
 export declare class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
-    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+    changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }
 export {};

package/dist/devices/evse.js

@@ -57,20 +57,32 @@ export class Evse extends MatterbridgeEndpoint {
     }
 }
 export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEvse.Feature.ChargingPreferences) {
-    disable() {
+    async disable() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Disable charging (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('disable', { request: {}, cluster: EnergyEvseServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('EnergyEvse.disable', {
+            command: 'disable',
+            request: {},
+            cluster: EnergyEvseServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeEnergyEvseServer disable called`);
         this.state.supplyState = EnergyEvse.SupplyState.Disabled;
         if (this.state.state === EnergyEvse.State.PluggedInCharging) {
             this.state.state = EnergyEvse.State.PluggedInDemand;
         }
     }
-    enableCharging(request) {
+    async enableCharging(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`EnableCharging (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('enableCharging', { request, cluster: EnergyEvseServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('EnergyEvse.enableCharging', {
+            command: 'enableCharging',
+            request,
+            cluster: EnergyEvseServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug(`MatterbridgeEnergyEvseServer enableCharging called`);
         this.state.supplyState = EnergyEvse.SupplyState.ChargingEnabled;
         if (this.state.state === EnergyEvse.State.PluggedInDemand) {
@@ -97,10 +109,16 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEv
     }
 }
 export class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
-    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: EnergyEvseModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('EnergyEvseMode.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: EnergyEvseModeServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
             device.log.error(`MatterbridgeEnergyEvseModeServer changeToMode called with unsupported newMode: ${request.newMode}`);

package/dist/devices/laundryWasher.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { LaundryWasherModeServer } from '@matter/node/behaviors/laundry-washer-mode';
 import { LaundryWasherControls } from '@matter/types/clusters/laundry-washer-controls';
 import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
@@ -13,5 +12,5 @@ export declare class LaundryWasher extends MatterbridgeEndpoint {
 export declare class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
     initialize(): void;
     protected handleOnOffChange(onOff: boolean): void;
-    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+    changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }

package/dist/devices/laundryWasher.js

@@ -63,10 +63,16 @@ export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer
             this.state.currentMode = 2;
         }
     }
-    changeToMode(request) {
+    async changeToMode(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`ChangeToMode (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('changeToMode', { request, cluster: LaundryWasherModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('LaundryWasherMode.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: LaundryWasherModeServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
         if (supportedMode) {
             device.log.debug(`MatterbridgeLaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} => ${supportedMode.label}`);

package/dist/devices/microwaveOven.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { MicrowaveOvenControlServer } from '@matter/node/behaviors/microwave-oven-control';
 import { MicrowaveOvenControl } from '@matter/types/clusters/microwave-oven-control';
 import { MicrowaveOvenMode } from '@matter/types/clusters/microwave-oven-mode';
@@ -87,6 +86,6 @@ declare const MatterbridgeMicrowaveOvenControlServer_base: import("@matter/node"
 export declare class MatterbridgeMicrowaveOvenControlServer extends MatterbridgeMicrowaveOvenControlServer_base {
     initialize(): Promise<void>;
     setCookingParameters(request: MicrowaveOvenControl.SetCookingParametersRequest): Promise<void>;
-    addMoreTime(request: MicrowaveOvenControl.AddMoreTimeRequest): MaybePromise;
+    addMoreTime(request: MicrowaveOvenControl.AddMoreTimeRequest): Promise<void>;
 }
 export {};

package/dist/devices/microwaveOven.js

@@ -50,7 +50,13 @@ export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControl
     async 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 });
+        await device.commandHandler.executeHandler('MicrowaveOvenControl.setCookingParameters', {
+            command: 'setCookingParameters',
+            request,
+            cluster: MicrowaveOvenControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         if (request.cookMode !== undefined) {
             device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting cookMode to ${request.cookMode}`);
             await this.endpoint.setStateOf(MicrowaveOvenModeServer, { currentMode: request.cookMode });
@@ -82,10 +88,16 @@ export class MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControl
             await this.endpoint.setStateOf(MatterbridgeOperationalStateServer, { operationalState: OperationalState.OperationalStateEnum.Running });
         }
     }
-    addMoreTime(request) {
+    async 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 });
+        await device.commandHandler.executeHandler('MicrowaveOvenControl.addMoreTime', {
+            command: 'addMoreTime',
+            request,
+            cluster: MicrowaveOvenControlServer.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;

package/dist/devices/roboticVacuumCleaner.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { RvcCleanModeServer } from '@matter/node/behaviors/rvc-clean-mode';
 import { RvcOperationalStateServer } from '@matter/node/behaviors/rvc-operational-state';
 import { RvcRunModeServer } from '@matter/node/behaviors/rvc-run-mode';
@@ -17,13 +16,13 @@ export declare class RoboticVacuumCleaner extends MatterbridgeEndpoint {
     createDefaultRvcOperationalStateClusterServer(phaseList?: string[] | null, currentPhase?: number | null, operationalStateList?: RvcOperationalState.OperationalStateStruct[], operationalState?: RvcOperationalState.OperationalState, operationalError?: RvcOperationalState.ErrorStateStruct): this;
 }
 export declare class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
-    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+    changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }
 export declare class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
-    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+    changeToMode(request: ModeBase.ChangeToModeRequest): Promise<ModeBase.ChangeToModeResponse>;
 }
 export declare class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
-    pause(): MaybePromise<OperationalState.OperationalCommandResponse>;
-    resume(): MaybePromise<OperationalState.OperationalCommandResponse>;
-    goHome(): MaybePromise<OperationalState.OperationalCommandResponse>;
+    pause(): Promise<OperationalState.OperationalCommandResponse>;
+    resume(): Promise<OperationalState.OperationalCommandResponse>;
+    goHome(): Promise<OperationalState.OperationalCommandResponse>;
 }

package/dist/devices/roboticVacuumCleaner.js

@@ -97,10 +97,16 @@ export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
     }
 }
 export class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
-    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: RvcRunModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('RvcRunMode.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: RvcRunModeServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
             device.log.error(`MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
@@ -123,10 +129,16 @@ export class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
     }
 }
 export class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
-    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: RvcCleanModeServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('RvcCleanMode.changeToMode', {
+            command: 'changeToMode',
+            request,
+            cluster: RvcCleanModeServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         const supported = this.state.supportedModes.find((mode) => mode.mode === request.newMode);
         if (!supported) {
             device.log.error(`MatterbridgeRvcCleanModeServer changeToMode called with unsupported newMode: ${request.newMode}`);
@@ -138,10 +150,16 @@ export class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
     }
 }
 export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
-    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: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('RvcOperationalState.pause', {
+            command: 'pause',
+            request: {},
+            cluster: RvcOperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
         this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
         this.state.operationalState = RvcOperationalState.OperationalState.Paused;
@@ -150,10 +168,16 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
             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: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('RvcOperationalState.resume', {
+            command: 'resume',
+            request: {},
+            cluster: RvcOperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
         this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
         this.state.operationalState = RvcOperationalState.OperationalState.Running;
@@ -162,10 +186,16 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateSe
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
     }
-    goHome() {
+    async goHome() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`GoHome (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        device.commandHandler.executeHandler('goHome', { request: {}, cluster: RvcOperationalStateServer.id, attributes: this.state, endpoint: this.endpoint });
+        await device.commandHandler.executeHandler('RvcOperationalState.goHome', {
+            command: 'goHome',
+            request: {},
+            cluster: RvcOperationalStateServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
         device.log.debug('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
         this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
         this.state.operationalState = RvcOperationalState.OperationalState.Docked;

package/dist/devices/temperatureControl.d.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@matter/general';
 import { TemperatureControlServer } from '@matter/node/behaviors/temperature-control';
 import { TemperatureControl } from '@matter/types/clusters/temperature-control';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
@@ -71,7 +70,7 @@ declare const MatterbridgeLevelTemperatureControlServer_base: import("@matter/no
 }>, readonly [TemperatureControl.Feature.TemperatureLevel]>, typeof TemperatureControlServer, import("@matter/node/behaviors/temperature-control").TemperatureControlInterface>;
 export declare class MatterbridgeLevelTemperatureControlServer extends MatterbridgeLevelTemperatureControlServer_base {
     initialize(): void;
-    setTemperature(request: TemperatureControl.SetTemperatureRequest): MaybePromise;
+    setTemperature(request: TemperatureControl.SetTemperatureRequest): Promise<void>;
 }
 declare const MatterbridgeNumberTemperatureControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
     readonly id: 86;
@@ -140,6 +139,6 @@ declare const MatterbridgeNumberTemperatureControlServer_base: import("@matter/n
 }>, readonly [TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep]>, typeof TemperatureControlServer, import("@matter/node/behaviors/temperature-control").TemperatureControlInterface>;
 export declare class MatterbridgeNumberTemperatureControlServer extends MatterbridgeNumberTemperatureControlServer_base {
     initialize(): void;
-    setTemperature(request: TemperatureControl.SetTemperatureRequest): MaybePromise;
+    setTemperature(request: TemperatureControl.SetTemperatureRequest): Promise<void>;
 }
 export {};