@matterbridge/core 3.10.4-dev-20260804-734583a → 3.10.4-dev-20260804-4e99208

package/dist/behaviors/colorControlServer.d.ts

@@ -9,11 +9,22 @@ declare const MatterbridgeColorControlServer_base: import("@matter/node").Cluste
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/color-control").ColorControlBaseServer.Internal, "colorControl">;
 export declare class MatterbridgeColorControlServer extends MatterbridgeColorControlServer_base {
     moveToHue(request: ColorControl.MoveToHueRequest): Promise<void>;
+    moveHue(request: ColorControl.MoveHueRequest): Promise<void>;
+    stepHue(request: ColorControl.StepHueRequest): Promise<void>;
     enhancedMoveToHue(request: ColorControl.EnhancedMoveToHueRequest): Promise<void>;
+    enhancedMoveHue(request: ColorControl.EnhancedMoveHueRequest): Promise<void>;
+    enhancedStepHue(request: ColorControl.EnhancedStepHueRequest): Promise<void>;
     moveToSaturation(request: ColorControl.MoveToSaturationRequest): Promise<void>;
+    moveSaturation(request: ColorControl.MoveSaturationRequest): Promise<void>;
+    stepSaturation(request: ColorControl.StepSaturationRequest): Promise<void>;
     moveToHueAndSaturation(request: ColorControl.MoveToHueAndSaturationRequest): Promise<void>;
     enhancedMoveToHueAndSaturation(request: ColorControl.EnhancedMoveToHueAndSaturationRequest): Promise<void>;
     moveToColor(request: ColorControl.MoveToColorRequest): Promise<void>;
+    moveColor(request: ColorControl.MoveColorRequest): Promise<void>;
+    stepColor(request: ColorControl.StepColorRequest): Promise<void>;
     moveToColorTemperature(request: ColorControl.MoveToColorTemperatureRequest): Promise<void>;
+    moveColorTemperature(request: ColorControl.MoveColorTemperatureRequest): Promise<void>;
+    stepColorTemperature(request: ColorControl.StepColorTemperatureRequest): Promise<void>;
+    stopMoveStep(request: ColorControl.StopMoveStepRequest): Promise<void>;
 }
 export {};

package/dist/behaviors/colorControlServer.js

@@ -16,6 +16,34 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
         device.log.debug(`MatterbridgeColorControlServer: moveToHue called`);
         await super.moveToHue(request);
     }
+    async moveHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Moving hue with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveHue', {
+            command: 'moveHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveHue called`);
+        await super.moveHue(request);
+    }
+    async stepHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping hue with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.stepHue', {
+            command: 'stepHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: stepHue called`);
+        await super.stepHue(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})`);
@@ -30,6 +58,34 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
         device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHue called`);
         await super.enhancedMoveToHue(request);
     }
+    async enhancedMoveHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Moving enhanced hue with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.enhancedMoveHue', {
+            command: 'enhancedMoveHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveHue called`);
+        await super.enhancedMoveHue(request);
+    }
+    async enhancedStepHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping enhanced hue with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.enhancedStepHue', {
+            command: 'enhancedStepHue',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: enhancedStepHue called`);
+        await super.enhancedStepHue(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})`);
@@ -44,6 +100,34 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
         device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called`);
         await super.moveToSaturation(request);
     }
+    async moveSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Moving saturation with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveSaturation', {
+            command: 'moveSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveSaturation called`);
+        await super.moveSaturation(request);
+    }
+    async stepSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping saturation with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.stepSaturation', {
+            command: 'stepSaturation',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: stepSaturation called`);
+        await super.stepSaturation(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})`);
@@ -86,6 +170,34 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
         device.log.debug(`MatterbridgeColorControlServer: moveToColor called`);
         await super.moveToColor(request);
     }
+    async moveColor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Moving color with rateX ${request.rateX} and rateY ${request.rateY} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveColor', {
+            command: 'moveColor',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveColor called`);
+        await super.moveColor(request);
+    }
+    async stepColor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping color with stepX ${request.stepX} and stepY ${request.stepY} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.stepColor', {
+            command: 'stepColor',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: stepColor called`);
+        await super.stepColor(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})`);
@@ -100,4 +212,46 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
         device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called`);
         await super.moveToColorTemperature(request);
     }
+    async moveColorTemperature(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Moving color temperature with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.moveColorTemperature', {
+            command: 'moveColorTemperature',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: moveColorTemperature called`);
+        await super.moveColorTemperature(request);
+    }
+    async stepColorTemperature(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping color temperature with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.stepColorTemperature', {
+            command: 'stepColorTemperature',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: stepColorTemperature called`);
+        await super.stepColorTemperature(request);
+    }
+    async stopMoveStep(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stopping color move/step (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ColorControl.stopMoveStep', {
+            command: 'stopMoveStep',
+            request,
+            cluster: ColorControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeColorControlServer: stopMoveStep called`);
+        await super.stopMoveStep(request);
+    }
 }

package/dist/behaviors/levelControlServer.d.ts

@@ -3,4 +3,10 @@ import type { LevelControl } from '@matter/types/clusters/level-control';
 export declare class MatterbridgeLevelControlServer extends LevelControlServer {
     moveToLevel(request: LevelControl.MoveToLevelRequest): Promise<void>;
     moveToLevelWithOnOff(request: LevelControl.MoveToLevelRequest): Promise<void>;
+    move(request: LevelControl.MoveRequest): Promise<void>;
+    moveWithOnOff(request: LevelControl.MoveRequest): Promise<void>;
+    step(request: LevelControl.StepRequest): Promise<void>;
+    stepWithOnOff(request: LevelControl.StepRequest): Promise<void>;
+    stop(request: LevelControl.StopRequest): Promise<void>;
+    stopWithOnOff(request: LevelControl.StopRequest): Promise<void>;
 }

package/dist/behaviors/levelControlServer.js

@@ -29,4 +29,88 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
         device.log.debug(`MatterbridgeLevelControlServer: moveToLevelWithOnOff called`);
         await super.moveToLevelWithOnOff(request);
     }
+    async move(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('LevelControl.move', {
+            command: 'move',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeLevelControlServer: move called`);
+        await super.move(request);
+    }
+    async moveWithOnOff(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('LevelControl.moveWithOnOff', {
+            command: 'moveWithOnOff',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeLevelControlServer: moveWithOnOff called`);
+        await super.moveWithOnOff(request);
+    }
+    async step(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('LevelControl.step', {
+            command: 'step',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeLevelControlServer: step called`);
+        await super.step(request);
+    }
+    async stepWithOnOff(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('LevelControl.stepWithOnOff', {
+            command: 'stepWithOnOff',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeLevelControlServer: stepWithOnOff called`);
+        await super.stepWithOnOff(request);
+    }
+    async stop(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('LevelControl.stop', {
+            command: 'stop',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeLevelControlServer: stop called`);
+        await super.stop(request);
+    }
+    async stopWithOnOff(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('LevelControl.stopWithOnOff', {
+            command: 'stopWithOnOff',
+            request,
+            cluster: LevelControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeLevelControlServer: stopWithOnOff called`);
+        await super.stopWithOnOff(request);
+    }
 }

package/dist/behaviors/onOffServer.d.ts

@@ -1,6 +1,24 @@
 import { OnOffServer } from '@matter/node/behaviors/on-off';
-export declare class MatterbridgeOnOffServer extends OnOffServer {
+import { OnOff } from '@matter/types/clusters/on-off';
+declare const MatterbridgeOnOffServer_base: import("@matter/node").ClusterBehavior.Type<typeof OnOffServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<OnOff, {
+    deadFrontBehavior: false;
+    lighting: true;
+    offOnly: false;
+}>, {
+    deadFrontBehavior: false;
+    lighting: false;
+    offOnly: false;
+}>, {
+    deadFrontBehavior: false;
+    lighting: true;
+    offOnly: false;
+}>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/on-off").OnOffBaseServer.Internal, "onOff">;
+export declare class MatterbridgeOnOffServer extends MatterbridgeOnOffServer_base {
     on(): Promise<void>;
     off(): Promise<void>;
     toggle(): Promise<void>;
+    offWithEffect(request: OnOff.OffWithEffectRequest): Promise<void>;
+    onWithRecallGlobalScene(): Promise<void>;
+    onWithTimedOff(request: OnOff.OnWithTimedOffRequest): Promise<void>;
 }
+export {};

package/dist/behaviors/onOffServer.js

@@ -1,6 +1,7 @@
 import { OnOffServer } from '@matter/node/behaviors/on-off';
+import { OnOff } from '@matter/types/clusters/on-off';
 import { MatterbridgeServer } from './matterbridgeServer.js';
-export class MatterbridgeOnOffServer extends OnOffServer {
+export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Lighting) {
     async on() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -43,4 +44,46 @@ export class MatterbridgeOnOffServer extends OnOffServer {
         device.log.debug(`MatterbridgeOnOffServer: toggle called`);
         await super.toggle();
     }
+    async offWithEffect(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Switching device off with effect ${request.effectIdentifier} and variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OnOff.offWithEffect', {
+            command: 'offWithEffect',
+            request,
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeOnOffServer: offWithEffect called`);
+        await super.offWithEffect(request);
+    }
+    async onWithRecallGlobalScene() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Switching device on with recall global scene (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OnOff.onWithRecallGlobalScene', {
+            command: 'onWithRecallGlobalScene',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeOnOffServer: onWithRecallGlobalScene called`);
+        await super.onWithRecallGlobalScene();
+    }
+    async onWithTimedOff(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Switching device on with timed off control ${JSON.stringify(request.onOffControl)}, offWaitTime ${request.offWaitTime} and onTime ${request.onTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('OnOff.onWithTimedOff', {
+            command: 'onWithTimedOff',
+            request,
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeOnOffServer: onWithTimedOff called`);
+        await super.onWithTimedOff(request);
+    }
 }

package/dist/devices/basicVideoPlayer.js

@@ -33,7 +33,7 @@ export class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeMediaPlaybackServer initialized: currentState is ${this.state.currentState}`);
-        this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
+        this.reactTo(this.agent.get(MatterbridgeOnOffServer.with()).events.onOff$Changed, this.handleOnOffChange);
     }
     handleOnOffChange(_onOff) {
         this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
@@ -48,7 +48,7 @@ export class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff)
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
             this.state.currentState = MediaPlayback.PlaybackState.Playing;
         return { status: MediaPlayback.Status.Success };
     }
@@ -62,7 +62,7 @@ export class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff)
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
             this.state.currentState = MediaPlayback.PlaybackState.Paused;
         return { status: MediaPlayback.Status.Success };
     }
@@ -76,7 +76,7 @@ export class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff)
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
             this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
         return { status: MediaPlayback.Status.Success };
     }

package/dist/devices/dishwasher.js

@@ -2,6 +2,7 @@ import { DishwasherAlarmServer } from '@matter/node/behaviors/dishwasher-alarm';
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
+import { OnOff } from '@matter/types/clusters/on-off';
 import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
 import { MatterbridgeOnOffServer } from '../behaviors/onOffServer.js';
 import { dishwasher, powerSource } from '../matterbridgeDeviceTypes.js';
@@ -47,7 +48,7 @@ export class MatterbridgeDishwasherModeServer extends DishwasherModeServer {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeDishwasherModeServer initialized: currentMode is ${this.state.currentMode}`);
         this.state.currentMode = 2;
-        this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
+        this.reactTo(this.agent.get(MatterbridgeOnOffServer.with(OnOff.Feature.DeadFrontBehavior)).events.onOff$Changed, this.handleOnOffChange);
     }
     handleOnOffChange(onOff) {
         const device = this.endpoint.stateOf(MatterbridgeServer);

package/dist/devices/laundryWasher.js

@@ -3,6 +3,7 @@ import { LaundryWasherModeServer } from '@matter/node/behaviors/laundry-washer-m
 import { LaundryWasherControls } from '@matter/types/clusters/laundry-washer-controls';
 import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
+import { OnOff } from '@matter/types/clusters/on-off';
 import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
 import { MatterbridgeOnOffServer } from '../behaviors/onOffServer.js';
 import { laundryWasher, powerSource } from '../matterbridgeDeviceTypes.js';
@@ -54,7 +55,7 @@ export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeLaundryWasherModeServer initialized: currentMode is ${this.state.currentMode}`);
-        this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
+        this.reactTo(this.agent.get(MatterbridgeOnOffServer.with(OnOff.Feature.DeadFrontBehavior)).events.onOff$Changed, this.handleOnOffChange);
     }
     handleOnOffChange(onOff) {
         const device = this.endpoint.stateOf(MatterbridgeServer);

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -107,6 +107,20 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof OnOff)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'OnOff.onWithRecallGlobalScene': {
+        command: 'onWithRecallGlobalScene';
+        request: {};
+        cluster: 'onOff';
+        attributes: ClusterAttributeValues<(typeof OnOff)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'OnOff.onWithTimedOff': {
+        command: 'onWithTimedOff';
+        request: OnOff.OnWithTimedOffRequest;
+        cluster: 'onOff';
+        attributes: ClusterAttributeValues<(typeof OnOff)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'moveToLevel': CommandHandlerData<'LevelControl.moveToLevel'>;
     'moveToLevelWithOnOff': CommandHandlerData<'LevelControl.moveToLevelWithOnOff'>;
     'LevelControl.moveToLevel': {
@@ -123,6 +137,48 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof LevelControl)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'LevelControl.move': {
+        command: 'move';
+        request: LevelControl.MoveRequest;
+        cluster: 'levelControl';
+        attributes: ClusterAttributeValues<(typeof LevelControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'LevelControl.moveWithOnOff': {
+        command: 'moveWithOnOff';
+        request: LevelControl.MoveRequest;
+        cluster: 'levelControl';
+        attributes: ClusterAttributeValues<(typeof LevelControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'LevelControl.step': {
+        command: 'step';
+        request: LevelControl.StepRequest;
+        cluster: 'levelControl';
+        attributes: ClusterAttributeValues<(typeof LevelControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'LevelControl.stepWithOnOff': {
+        command: 'stepWithOnOff';
+        request: LevelControl.StepRequest;
+        cluster: 'levelControl';
+        attributes: ClusterAttributeValues<(typeof LevelControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'LevelControl.stop': {
+        command: 'stop';
+        request: LevelControl.StopRequest;
+        cluster: 'levelControl';
+        attributes: ClusterAttributeValues<(typeof LevelControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'LevelControl.stopWithOnOff': {
+        command: 'stopWithOnOff';
+        request: LevelControl.StopRequest;
+        cluster: 'levelControl';
+        attributes: ClusterAttributeValues<(typeof LevelControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'moveToColor': CommandHandlerData<'ColorControl.moveToColor'>;
     'moveColor': CommandHandlerData<'ColorControl.moveColor'>;
     'stepColor': CommandHandlerData<'ColorControl.stepColor'>;
@@ -243,6 +299,27 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof ColorControl)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'ColorControl.moveColorTemperature': {
+        command: 'moveColorTemperature';
+        request: ColorControl.MoveColorTemperatureRequest;
+        cluster: 'colorControl';
+        attributes: ClusterAttributeValues<(typeof ColorControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'ColorControl.stepColorTemperature': {
+        command: 'stepColorTemperature';
+        request: ColorControl.StepColorTemperatureRequest;
+        cluster: 'colorControl';
+        attributes: ClusterAttributeValues<(typeof ColorControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'ColorControl.stopMoveStep': {
+        command: 'stopMoveStep';
+        request: ColorControl.StopMoveStepRequest;
+        cluster: 'colorControl';
+        attributes: ClusterAttributeValues<(typeof ColorControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'upOrOpen': CommandHandlerData<'WindowCovering.upOrOpen'>;
     'downOrClose': CommandHandlerData<'WindowCovering.downOrClose'>;
     'stopMotion': CommandHandlerData<'WindowCovering.stopMotion'>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.4-dev-20260804-734583a",
+  "version": "3.10.4-dev-20260804-4e99208",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,10 +132,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.8",
-    "@matterbridge/dgram": "3.10.4-dev-20260804-734583a",
-    "@matterbridge/thread": "3.10.4-dev-20260804-734583a",
-    "@matterbridge/types": "3.10.4-dev-20260804-734583a",
-    "@matterbridge/utils": "3.10.4-dev-20260804-734583a",
+    "@matterbridge/dgram": "3.10.4-dev-20260804-4e99208",
+    "@matterbridge/thread": "3.10.4-dev-20260804-4e99208",
+    "@matterbridge/types": "3.10.4-dev-20260804-4e99208",
+    "@matterbridge/utils": "3.10.4-dev-20260804-4e99208",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.1",