@matterbridge/core 3.10.6-dev-20260820-36b52be → 3.10.6-dev-20260821-16f33ac

package/dist/demoDevices.js

@@ -3,8 +3,14 @@ import { AirQuality } from '@matter/types/clusters/air-quality';
 import { FanControl } from '@matter/types/clusters/fan-control';
 import { PowerSource } from '@matter/types/clusters/power-source';
 import { EndpointNumber } from '@matter/types/datatype';
+import { BasicVideoPlayer } from './devices/basicVideoPlayer.js';
+import { CastingVideoClient } from './devices/castingVideoClient.js';
+import { CastingVideoPlayer } from './devices/castingVideoPlayer.js';
 import { Closure } from './devices/closure.js';
+import { ContentApp } from './devices/contentApp.js';
 import { IrrigationSystem } from './devices/irrigationSystem.js';
+import { Speaker } from './devices/speaker.js';
+import { VideoRemoteControl } from './devices/videoRemoteControl.js';
 import { getSupportedDeviceType } from './matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { getSemtag } from './matterbridgeEndpointHelpers.js';
@@ -251,4 +257,43 @@ export async function createDemoDevices(matterbridge) {
     await registerDevice(ep, 'Air Purifier', 'HVAC-09-03');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('ThermostatController'), bridgedNode, powerSource], { id: 'ThermostatController', number: EndpointNumber(9_04) });
     await registerDevice(ep, 'Thermostat Controller', 'HVAC-09-04');
+    ep = new BasicVideoPlayer('Basic Video Player', 'MEDIA-10-02', { id: 'BasicVideoPlayer', number: EndpointNumber(10_02) });
+    await registerDevice(ep, 'Basic Video Player', 'MEDIA-10-02');
+    ep = new CastingVideoPlayer('Casting Video Player', 'MEDIA-10-03', { id: 'CastingVideoPlayer', number: EndpointNumber(10_03) });
+    await registerDevice(ep, 'Casting Video Player', 'MEDIA-10-03');
+    ep = new Speaker('Speaker', 'MEDIA-10-04', { id: 'Speaker', number: EndpointNumber(10_04) });
+    await registerDevice(ep, 'Speaker', 'MEDIA-10-04');
+    ep = new ContentApp('Content App', 'MEDIA-10-05', { id: 'ContentApp', number: EndpointNumber(10_05) });
+    await registerDevice(ep, 'Content App', 'MEDIA-10-05');
+    ep = new CastingVideoClient('Casting Video Client', 'MEDIA-10-06', { id: 'CastingVideoClient', number: EndpointNumber(10_06) });
+    await registerDevice(ep, 'Casting Video Client', 'MEDIA-10-06');
+    ep = new VideoRemoteControl('Video Remote Control', 'MEDIA-10-07', { id: 'VideoRemoteControl', number: EndpointNumber(10_07) });
+    await registerDevice(ep, 'Video Remote Control', 'MEDIA-10-07');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('ModeSelect'), bridgedNode, powerSource], { id: 'ModeSelect', number: EndpointNumber(11_01) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    ep.createDefaultModeSelectClusterServer('Mode', [
+        { label: 'Mode 1', mode: 0, semanticTags: [] },
+        { label: 'Mode 2', mode: 1, semanticTags: [] },
+    ]);
+    await registerDevice(ep, 'Mode Select', 'GENERIC-11-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Aggregator'), bridgedNode, powerSource], { id: 'Aggregator', number: EndpointNumber(11_02) });
+    ep.createDefaultPowerSourceWiredClusterServer();
+    await ep.addFixedLabel('composed', 'Aggregator');
+    ep.addChildDeviceType('Plug1', getSupportedDeviceType('OnOffPlugInUnit'), {
+        number: EndpointNumber(11_02_1),
+        tagList: [getSemtag(CommonNumberTag.One)],
+    }).addRequiredClusters();
+    ep.addChildDeviceType('Plug2', getSupportedDeviceType('OnOffPlugInUnit'), {
+        number: EndpointNumber(11_02_2),
+        tagList: [getSemtag(CommonNumberTag.Two)],
+    }).addRequiredClusters();
+    ep.addChildDeviceType('Plug3', getSupportedDeviceType('OnOffPlugInUnit'), {
+        number: EndpointNumber(11_02_3),
+        tagList: [getSemtag(CommonNumberTag.Three)],
+    }).addRequiredClusters();
+    ep.addChildDeviceType('Plug4', getSupportedDeviceType('OnOffPlugInUnit'), {
+        number: EndpointNumber(11_02_4),
+        tagList: [getSemtag(CommonNumberTag.Four)],
+    }).addRequiredClusters();
+    await registerDevice(ep, 'Aggregator', 'GENERIC-11-02');
 }

package/dist/devices/basicVideoPlayer.d.ts

@@ -1,29 +1,14 @@
-import { KeypadInputServer } from '@matter/node/behaviors/keypad-input';
-import { MediaPlaybackServer } from '@matter/node/behaviors/media-playback';
-import { KeypadInput } from '@matter/types/clusters/keypad-input';
 import { MediaPlayback } from '@matter/types/clusters/media-playback';
+import type { EndpointNumber } from '@matter/types/datatype';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type MediaPowerSourceType } from './mediaHelpers.js';
 export interface BasicVideoPlayerOptions {
     onOff?: boolean;
     playbackState?: MediaPlayback.PlaybackState;
+    powerSourceType?: MediaPowerSourceType;
+    id?: string;
+    number?: EndpointNumber;
 }
 export declare class BasicVideoPlayer extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: BasicVideoPlayerOptions);
-    createDefaultMediaPlaybackClusterServer(currentState: MediaPlayback.PlaybackState): this;
-    createDefaultKeypadInputClusterServer(): this;
-}
-export declare class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
-    initialize(): void;
-    protected handleOnOffChange(_onOff: boolean): void;
-    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): Promise<KeypadInput.SendKeyResponse>;
 }

package/dist/devices/basicVideoPlayer.js

@@ -1,149 +1,18 @@
-import { KeypadInputServer } from '@matter/node/behaviors/keypad-input';
-import { MediaPlaybackServer } from '@matter/node/behaviors/media-playback';
-import { KeypadInput } from '@matter/types/clusters/keypad-input';
 import { MediaPlayback } from '@matter/types/clusters/media-playback';
-import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
-import { MatterbridgeOnOffServer } from '../behaviors/onOffServer.js';
 import { basicVideoPlayer, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createDefaultKeypadInputClusterServer, createDefaultMediaPlaybackClusterServer, createDefaultMediaPowerSourceClusterServer, } from './mediaHelpers.js';
 export class BasicVideoPlayer extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
-        const { onOff = false, playbackState = MediaPlayback.PlaybackState.NotPlaying } = options;
-        super([basicVideoPlayer, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        const { onOff = false, playbackState = MediaPlayback.PlaybackState.NotPlaying, powerSourceType = 'Wired' } = options;
+        super(powerSourceType === 'None' ? [basicVideoPlayer] : [basicVideoPlayer, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+        });
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Basic Video Player');
-        this.createDefaultPowerSourceWiredClusterServer();
+        createDefaultMediaPowerSourceClusterServer(this, powerSourceType);
         this.createOnOffClusterServer(onOff);
-        this.createDefaultMediaPlaybackClusterServer(playbackState);
-        this.createDefaultKeypadInputClusterServer();
-    }
-    createDefaultMediaPlaybackClusterServer(currentState) {
-        this.behaviors.require(MatterbridgeMediaPlaybackServer.enable({
-            commands: { next: true, previous: true, skipForward: true, skipBackward: true },
-        }), {
-            currentState,
-        });
-        return this;
-    }
-    createDefaultKeypadInputClusterServer() {
-        this.behaviors.require(MatterbridgeKeypadInputServer, {});
-        return this;
-    }
-}
-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.with()).events.onOff$Changed, this.handleOnOffChange);
-    }
-    handleOnOffChange(_onOff) {
-        this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
-    }
-    async play() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Play (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('MediaPlayback.play', {
-            command: 'play',
-            request: {},
-            cluster: MediaPlaybackServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
-            this.state.currentState = MediaPlayback.PlaybackState.Playing;
-        return { status: MediaPlayback.Status.Success };
-    }
-    async pause() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Pause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('MediaPlayback.pause', {
-            command: 'pause',
-            request: {},
-            cluster: MediaPlaybackServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
-            this.state.currentState = MediaPlayback.PlaybackState.Paused;
-        return { status: MediaPlayback.Status.Success };
-    }
-    async stop() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('MediaPlayback.stop', {
-            command: 'stop',
-            request: {},
-            cluster: MediaPlaybackServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
-            this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
-        return { status: MediaPlayback.Status.Success };
-    }
-    async previous() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Previous (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('MediaPlayback.previous', {
-            command: 'previous',
-            request: {},
-            cluster: MediaPlaybackServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        return { status: MediaPlayback.Status.Success };
-    }
-    async next() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Next (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('MediaPlayback.next', {
-            command: 'next',
-            request: {},
-            cluster: MediaPlaybackServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        return { status: MediaPlayback.Status.Success };
-    }
-    async skipForward(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`SkipForward (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('MediaPlayback.skipForward', {
-            command: 'skipForward',
-            request,
-            cluster: MediaPlaybackServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        return { status: MediaPlayback.Status.Success };
-    }
-    async skipBackward(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`SkipBackward (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('MediaPlayback.skipBackward', {
-            command: 'skipBackward',
-            request,
-            cluster: MediaPlaybackServer.id,
-            attributes: this.state,
-            endpoint: this.endpoint,
-        });
-        return { status: MediaPlayback.Status.Success };
-    }
-}
-export class MatterbridgeKeypadInputServer extends KeypadInputServer {
-    initialize() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`MatterbridgeKeypadInputServer initialized`);
-    }
-    async sendKey(request) {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`SendKey keyCode ${request.keyCode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        await device.commandHandler.executeHandler('KeypadInput.sendKey', {
-            command: 'sendKey',
-            request,
-            cluster: KeypadInputServer.id,
-            attributes: {},
-            endpoint: this.endpoint,
-        });
-        return { status: KeypadInput.Status.Success };
+        createDefaultMediaPlaybackClusterServer(this, playbackState, true);
+        createDefaultKeypadInputClusterServer(this);
     }
 }

package/dist/devices/castingVideoClient.d.ts

@@ -0,0 +1,11 @@
+import type { EndpointNumber } from '@matter/types/datatype';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type MediaPowerSourceType } from './mediaHelpers.js';
+export interface CastingVideoClientOptions {
+    powerSourceType?: MediaPowerSourceType;
+    id?: string;
+    number?: EndpointNumber;
+}
+export declare class CastingVideoClient extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: CastingVideoClientOptions);
+}

package/dist/devices/castingVideoClient.js

@@ -0,0 +1,19 @@
+import { ApplicationBasic } from '@matter/types/clusters/application-basic';
+import { ContentLauncher } from '@matter/types/clusters/content-launcher';
+import { KeypadInput } from '@matter/types/clusters/keypad-input';
+import { OnOff } from '@matter/types/clusters/on-off';
+import { castingVideoClient, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createDefaultMediaBindingClusterServer, createDefaultMediaPowerSourceClusterServer } from './mediaHelpers.js';
+export class CastingVideoClient extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { powerSourceType = 'Wired' } = options;
+        super(powerSourceType === 'None' ? [castingVideoClient] : [castingVideoClient, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+        });
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Casting Video Client');
+        createDefaultMediaPowerSourceClusterServer(this, powerSourceType);
+        createDefaultMediaBindingClusterServer(this, [OnOff.id, KeypadInput.id, ContentLauncher.id, ApplicationBasic.id]);
+    }
+}

package/dist/devices/castingVideoPlayer.d.ts

@@ -1,16 +1,14 @@
-import { ContentLauncherServer } from '@matter/node/behaviors/content-launcher';
 import { MediaPlayback } from '@matter/types/clusters/media-playback';
+import type { EndpointNumber } from '@matter/types/datatype';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type MediaPowerSourceType } from './mediaHelpers.js';
 export interface CastingVideoPlayerOptions {
     onOff?: boolean;
     playbackState?: MediaPlayback.PlaybackState;
+    powerSourceType?: MediaPowerSourceType;
+    id?: string;
+    number?: EndpointNumber;
 }
 export declare class CastingVideoPlayer extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: CastingVideoPlayerOptions);
-    createDefaultMediaPlaybackClusterServer(currentState: MediaPlayback.PlaybackState): this;
-    createDefaultKeypadInputClusterServer(): this;
-    createDefaultContentLauncherClusterServer(): this;
-}
-export declare class MatterbridgeContentLauncherServer extends ContentLauncherServer {
-    initialize(): void;
 }

package/dist/devices/castingVideoPlayer.js

@@ -1,38 +1,19 @@
-import { ContentLauncherServer } from '@matter/node/behaviors/content-launcher';
 import { MediaPlayback } from '@matter/types/clusters/media-playback';
-import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
 import { castingVideoPlayer, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-import { MatterbridgeKeypadInputServer, MatterbridgeMediaPlaybackServer } from './basicVideoPlayer.js';
+import { createDefaultContentLauncherClusterServer, createDefaultKeypadInputClusterServer, createDefaultMediaPlaybackClusterServer, createDefaultMediaPowerSourceClusterServer, } from './mediaHelpers.js';
 export class CastingVideoPlayer extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
-        const { onOff = false, playbackState = MediaPlayback.PlaybackState.NotPlaying } = options;
-        super([castingVideoPlayer, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        const { onOff = false, playbackState = MediaPlayback.PlaybackState.NotPlaying, powerSourceType = 'Wired' } = options;
+        super(powerSourceType === 'None' ? [castingVideoPlayer] : [castingVideoPlayer, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+        });
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Casting Video Player');
-        this.createDefaultPowerSourceWiredClusterServer();
+        createDefaultMediaPowerSourceClusterServer(this, powerSourceType);
         this.createOnOffClusterServer(onOff);
-        this.createDefaultMediaPlaybackClusterServer(playbackState);
-        this.createDefaultKeypadInputClusterServer();
-        this.createDefaultContentLauncherClusterServer();
-    }
-    createDefaultMediaPlaybackClusterServer(currentState) {
-        this.behaviors.require(MatterbridgeMediaPlaybackServer, {
-            currentState,
-        });
-        return this;
-    }
-    createDefaultKeypadInputClusterServer() {
-        this.behaviors.require(MatterbridgeKeypadInputServer, {});
-        return this;
-    }
-    createDefaultContentLauncherClusterServer() {
-        this.behaviors.require(MatterbridgeContentLauncherServer, {});
-        return this;
-    }
-}
-export class MatterbridgeContentLauncherServer extends ContentLauncherServer {
-    initialize() {
-        const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`MatterbridgeContentLauncherServer initialized`);
+        createDefaultMediaPlaybackClusterServer(this, playbackState);
+        createDefaultKeypadInputClusterServer(this);
+        createDefaultContentLauncherClusterServer(this);
     }
 }

package/dist/devices/contentApp.d.ts

@@ -0,0 +1,19 @@
+import { ApplicationBasic } from '@matter/types/clusters/application-basic';
+import { VendorId } from '@matter/types/datatype';
+import type { EndpointNumber } from '@matter/types/datatype';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type MediaPowerSourceType } from './mediaHelpers.js';
+export interface ContentAppOptions {
+    applicationName?: string;
+    catalogVendorId?: number;
+    applicationId?: string;
+    status?: ApplicationBasic.ApplicationStatus;
+    applicationVersion?: string;
+    allowedVendorList?: VendorId[];
+    powerSourceType?: MediaPowerSourceType;
+    id?: string;
+    number?: EndpointNumber;
+}
+export declare class ContentApp extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: ContentAppOptions);
+}

package/dist/devices/contentApp.js

@@ -0,0 +1,19 @@
+import { ApplicationBasic } from '@matter/types/clusters/application-basic';
+import { VendorId } from '@matter/types/datatype';
+import { contentApp, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createDefaultApplicationBasicClusterServer, createDefaultApplicationLauncherClusterServer, createDefaultKeypadInputClusterServer, createDefaultMediaPowerSourceClusterServer, } from './mediaHelpers.js';
+export class ContentApp extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { applicationName = name, catalogVendorId = 0xfff1, applicationId = 'matterbridge-content-app', status = ApplicationBasic.ApplicationStatus.ActiveVisibleFocus, applicationVersion = '1.0.0', allowedVendorList = [VendorId(0xfff1)], powerSourceType = 'Wired', } = options;
+        super(powerSourceType === 'None' ? [contentApp] : [contentApp, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+        });
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Content App');
+        createDefaultMediaPowerSourceClusterServer(this, powerSourceType);
+        createDefaultKeypadInputClusterServer(this);
+        createDefaultApplicationLauncherClusterServer(this);
+        createDefaultApplicationBasicClusterServer(this, applicationName, catalogVendorId, applicationId, status, applicationVersion, allowedVendorList);
+    }
+}

package/dist/devices/export.d.ts

@@ -1,6 +1,10 @@
 export * from './basicVideoPlayer.js';
+export * from './castingVideoClient.js';
 export * from './castingVideoPlayer.js';
+export * from './contentApp.js';
+export * from './mediaHelpers.js';
 export * from './speaker.js';
+export * from './videoRemoteControl.js';
 export * from './closure.js';
 export * from './closurePanel.js';
 export * from './irrigationSystem.js';

package/dist/devices/export.js

@@ -1,6 +1,10 @@
 export * from './basicVideoPlayer.js';
+export * from './castingVideoClient.js';
 export * from './castingVideoPlayer.js';
+export * from './contentApp.js';
+export * from './mediaHelpers.js';
 export * from './speaker.js';
+export * from './videoRemoteControl.js';
 export * from './closure.js';
 export * from './closurePanel.js';
 export * from './irrigationSystem.js';

package/dist/devices/mediaHelpers.d.ts

@@ -0,0 +1,46 @@
+import { ApplicationBasicServer } from '@matter/node/behaviors/application-basic';
+import { ApplicationLauncherServer } from '@matter/node/behaviors/application-launcher';
+import { ContentLauncherServer } from '@matter/node/behaviors/content-launcher';
+import { KeypadInputServer } from '@matter/node/behaviors/keypad-input';
+import { MediaPlaybackServer } from '@matter/node/behaviors/media-playback';
+import { ApplicationBasic } from '@matter/types/clusters/application-basic';
+import { ApplicationLauncher } from '@matter/types/clusters/application-launcher';
+import { KeypadInput } from '@matter/types/clusters/keypad-input';
+import { MediaPlayback } from '@matter/types/clusters/media-playback';
+import type { ClusterId, VendorId } from '@matter/types/datatype';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
+    initialize(): void;
+    protected handleOnOffChange(_onOff: boolean): void;
+    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): Promise<KeypadInput.SendKeyResponse>;
+}
+export declare class MatterbridgeContentLauncherServer extends ContentLauncherServer {
+    initialize(): void;
+}
+export declare class MatterbridgeApplicationBasicServer extends ApplicationBasicServer {
+    initialize(): void;
+}
+export declare class MatterbridgeApplicationLauncherServer extends ApplicationLauncherServer {
+    initialize(): void;
+    launchApp(request: ApplicationLauncher.LaunchAppRequest): Promise<ApplicationLauncher.LauncherResponse>;
+    stopApp(request: ApplicationLauncher.StopAppRequest): Promise<ApplicationLauncher.LauncherResponse>;
+    hideApp(request: ApplicationLauncher.HideAppRequest): Promise<ApplicationLauncher.LauncherResponse>;
+}
+export declare function createDefaultMediaPlaybackClusterServer(endpoint: MatterbridgeEndpoint, currentState: MediaPlayback.PlaybackState, extendedCommands?: boolean): void;
+export declare function createDefaultKeypadInputClusterServer(endpoint: MatterbridgeEndpoint): void;
+export declare function createDefaultContentLauncherClusterServer(endpoint: MatterbridgeEndpoint): void;
+export declare function createDefaultApplicationLauncherClusterServer(endpoint: MatterbridgeEndpoint): void;
+export declare function createDefaultApplicationBasicClusterServer(endpoint: MatterbridgeEndpoint, applicationName: string, catalogVendorId: number, applicationId: string, status: ApplicationBasic.ApplicationStatus, applicationVersion: string, allowedVendorList: VendorId[]): void;
+export declare function createDefaultMediaBindingClusterServer(endpoint: MatterbridgeEndpoint, clientList: ClusterId[]): void;
+export type MediaPowerSourceType = 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+export declare function createDefaultMediaPowerSourceClusterServer(endpoint: MatterbridgeEndpoint, powerSourceType: MediaPowerSourceType): void;

package/dist/devices/mediaHelpers.js

@@ -0,0 +1,281 @@
+import { AccountLoginClient } from '@matter/node/behaviors/account-login';
+import { ApplicationBasicClient, ApplicationBasicServer } from '@matter/node/behaviors/application-basic';
+import { ApplicationLauncherClient, ApplicationLauncherServer } from '@matter/node/behaviors/application-launcher';
+import { AudioOutputClient } from '@matter/node/behaviors/audio-output';
+import { ChannelClient } from '@matter/node/behaviors/channel';
+import { ContentAppObserverClient } from '@matter/node/behaviors/content-app-observer';
+import { ContentControlClient } from '@matter/node/behaviors/content-control';
+import { ContentLauncherClient, ContentLauncherServer } from '@matter/node/behaviors/content-launcher';
+import { KeypadInputClient, KeypadInputServer } from '@matter/node/behaviors/keypad-input';
+import { LevelControlClient } from '@matter/node/behaviors/level-control';
+import { LowPowerClient } from '@matter/node/behaviors/low-power';
+import { MediaInputClient } from '@matter/node/behaviors/media-input';
+import { MediaPlaybackClient, MediaPlaybackServer } from '@matter/node/behaviors/media-playback';
+import { MessagesClient } from '@matter/node/behaviors/messages';
+import { OnOffClient } from '@matter/node/behaviors/on-off';
+import { TargetNavigatorClient } from '@matter/node/behaviors/target-navigator';
+import { WakeOnLanClient } from '@matter/node/behaviors/wake-on-lan';
+import { getClusterNameById } from '@matter/types/cluster';
+import { AccountLogin } from '@matter/types/clusters/account-login';
+import { ApplicationBasic } from '@matter/types/clusters/application-basic';
+import { ApplicationLauncher } from '@matter/types/clusters/application-launcher';
+import { AudioOutput } from '@matter/types/clusters/audio-output';
+import { Channel } from '@matter/types/clusters/channel';
+import { ContentAppObserver } from '@matter/types/clusters/content-app-observer';
+import { ContentControl } from '@matter/types/clusters/content-control';
+import { ContentLauncher } from '@matter/types/clusters/content-launcher';
+import { KeypadInput } from '@matter/types/clusters/keypad-input';
+import { LevelControl } from '@matter/types/clusters/level-control';
+import { LowPower } from '@matter/types/clusters/low-power';
+import { MediaInput } from '@matter/types/clusters/media-input';
+import { MediaPlayback } from '@matter/types/clusters/media-playback';
+import { Messages } from '@matter/types/clusters/messages';
+import { OnOff } from '@matter/types/clusters/on-off';
+import { TargetNavigator } from '@matter/types/clusters/target-navigator';
+import { WakeOnLan } from '@matter/types/clusters/wake-on-lan';
+import { MatterbridgeBindingServer } from '../behaviors/bindingServer.js';
+import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
+import { MatterbridgeOnOffServer } from '../behaviors/onOffServer.js';
+import { lowercaseFirstLetter } from '../matterbridgeEndpointHelpers.js';
+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.with()).events.onOff$Changed, this.handleOnOffChange);
+    }
+    handleOnOffChange(_onOff) {
+        this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
+    }
+    async play() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Play (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('MediaPlayback.play', {
+            command: 'play',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
+            this.state.currentState = MediaPlayback.PlaybackState.Playing;
+        return { status: MediaPlayback.Status.Success };
+    }
+    async pause() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Pause (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('MediaPlayback.pause', {
+            command: 'pause',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
+            this.state.currentState = MediaPlayback.PlaybackState.Paused;
+        return { status: MediaPlayback.Status.Success };
+    }
+    async stop() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('MediaPlayback.stop', {
+            command: 'stop',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer.with()).onOff)
+            this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
+        return { status: MediaPlayback.Status.Success };
+    }
+    async previous() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Previous (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('MediaPlayback.previous', {
+            command: 'previous',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        return { status: MediaPlayback.Status.Success };
+    }
+    async next() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Next (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('MediaPlayback.next', {
+            command: 'next',
+            request: {},
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        return { status: MediaPlayback.Status.Success };
+    }
+    async skipForward(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`SkipForward (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('MediaPlayback.skipForward', {
+            command: 'skipForward',
+            request,
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        return { status: MediaPlayback.Status.Success };
+    }
+    async skipBackward(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`SkipBackward (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('MediaPlayback.skipBackward', {
+            command: 'skipBackward',
+            request,
+            cluster: MediaPlaybackServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        return { status: MediaPlayback.Status.Success };
+    }
+}
+export class MatterbridgeKeypadInputServer extends KeypadInputServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeKeypadInputServer initialized`);
+    }
+    async sendKey(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`SendKey keyCode ${request.keyCode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('KeypadInput.sendKey', {
+            command: 'sendKey',
+            request,
+            cluster: KeypadInputServer.id,
+            attributes: {},
+            endpoint: this.endpoint,
+        });
+        return { status: KeypadInput.Status.Success };
+    }
+}
+export class MatterbridgeContentLauncherServer extends ContentLauncherServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeContentLauncherServer initialized`);
+    }
+}
+export class MatterbridgeApplicationBasicServer extends ApplicationBasicServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeApplicationBasicServer initialized`);
+    }
+}
+export class MatterbridgeApplicationLauncherServer extends ApplicationLauncherServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeApplicationLauncherServer initialized`);
+    }
+    async launchApp(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`LaunchApp (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ApplicationLauncher.launchApp', {
+            command: 'launchApp',
+            request,
+            cluster: ApplicationLauncherServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        return { status: ApplicationLauncher.Status.Success };
+    }
+    async stopApp(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`StopApp (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ApplicationLauncher.stopApp', {
+            command: 'stopApp',
+            request,
+            cluster: ApplicationLauncherServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        return { status: ApplicationLauncher.Status.Success };
+    }
+    async hideApp(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`HideApp (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ApplicationLauncher.hideApp', {
+            command: 'hideApp',
+            request,
+            cluster: ApplicationLauncherServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        return { status: ApplicationLauncher.Status.Success };
+    }
+}
+export function createDefaultMediaPlaybackClusterServer(endpoint, currentState, extendedCommands = false) {
+    endpoint.behaviors.require(extendedCommands
+        ? MatterbridgeMediaPlaybackServer.enable({ commands: { next: true, previous: true, skipForward: true, skipBackward: true } })
+        : MatterbridgeMediaPlaybackServer, { currentState });
+}
+export function createDefaultKeypadInputClusterServer(endpoint) {
+    endpoint.behaviors.require(MatterbridgeKeypadInputServer, {});
+}
+export function createDefaultContentLauncherClusterServer(endpoint) {
+    endpoint.behaviors.require(MatterbridgeContentLauncherServer, {});
+}
+export function createDefaultApplicationLauncherClusterServer(endpoint) {
+    endpoint.behaviors.require(MatterbridgeApplicationLauncherServer, {
+        currentApp: null,
+    });
+}
+export function createDefaultApplicationBasicClusterServer(endpoint, applicationName, catalogVendorId, applicationId, status, applicationVersion, allowedVendorList) {
+    endpoint.behaviors.require(MatterbridgeApplicationBasicServer, {
+        applicationName,
+        application: new ApplicationBasic.Application({ catalogVendorId, applicationId }),
+        status,
+        applicationVersion,
+        allowedVendorList,
+    });
+}
+const mediaClientBehaviors = new Map([
+    [OnOff.id, OnOffClient],
+    [KeypadInput.id, KeypadInputClient],
+    [MediaPlayback.id, MediaPlaybackClient],
+    [ContentLauncher.id, ContentLauncherClient],
+    [ApplicationBasic.id, ApplicationBasicClient],
+    [LevelControl.id, LevelControlClient],
+    [Messages.id, MessagesClient],
+    [WakeOnLan.id, WakeOnLanClient],
+    [Channel.id, ChannelClient],
+    [TargetNavigator.id, TargetNavigatorClient],
+    [MediaInput.id, MediaInputClient],
+    [LowPower.id, LowPowerClient],
+    [AudioOutput.id, AudioOutputClient],
+    [ApplicationLauncher.id, ApplicationLauncherClient],
+    [AccountLogin.id, AccountLoginClient],
+    [ContentControl.id, ContentControlClient],
+    [ContentAppObserver.id, ContentAppObserverClient],
+]);
+export function createDefaultMediaBindingClusterServer(endpoint, clientList) {
+    endpoint.behaviors.require(MatterbridgeBindingServer, { clientList });
+    for (const clusterId of clientList) {
+        const client = mediaClientBehaviors.get(clusterId);
+        if (client)
+            endpoint.type.clientClusters[lowercaseFirstLetter(getClusterNameById(clusterId))] ??= client;
+    }
+}
+export function createDefaultMediaPowerSourceClusterServer(endpoint, powerSourceType) {
+    switch (powerSourceType) {
+        case 'Rechargeable':
+            endpoint.createDefaultPowerSourceRechargeableBatteryClusterServer();
+            break;
+        case 'Replaceable':
+            endpoint.createDefaultPowerSourceReplaceableBatteryClusterServer();
+            break;
+        case 'Battery':
+            endpoint.createDefaultPowerSourceBatteryClusterServer();
+            break;
+        case 'Wired':
+            endpoint.createDefaultPowerSourceWiredClusterServer();
+            break;
+        case 'None':
+            break;
+    }
+}

package/dist/devices/speaker.d.ts

@@ -1,6 +1,15 @@
+import type { EndpointNumber } from '@matter/types/datatype';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type MediaPowerSourceType } from './mediaHelpers.js';
+export interface SpeakerOptions {
+    muted?: boolean;
+    volume?: number;
+    powerSourceType?: MediaPowerSourceType;
+    id?: string;
+    number?: EndpointNumber;
+}
 export declare class Speaker extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, muted?: boolean, volume?: number);
+    constructor(name: string, serial: string, options?: SpeakerOptions);
     setMuted(muted: boolean): Promise<void>;
     isMuted(): boolean;
     setVolume(level: number): Promise<void>;

package/dist/devices/speaker.js

@@ -1,17 +1,24 @@
 import { LevelControl } from '@matter/types/clusters/level-control';
 import { OnOff } from '@matter/types/clusters/on-off';
-import { speaker } from '../matterbridgeDeviceTypes.js';
+import { powerSource, speaker } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createDefaultMediaPowerSourceClusterServer } from './mediaHelpers.js';
 export class Speaker extends MatterbridgeEndpoint {
-    constructor(name, serial, muted = false, volume = 128) {
+    constructor(name, serial, options = {}) {
+        const { muted = false, powerSourceType = 'Wired' } = options;
+        let { volume = 128 } = options;
         if (!Number.isFinite(volume))
             volume = 128;
         if (volume < 1)
             volume = 1;
         if (volume > 254)
             volume = 254;
-        super([speaker], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        super(powerSourceType === 'None' ? [speaker] : [speaker, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+        });
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Speaker');
+        createDefaultMediaPowerSourceClusterServer(this, powerSourceType);
         this.createOnOffClusterServer(!muted);
         this.createLevelControlClusterServer(volume);
     }

package/dist/devices/videoRemoteControl.d.ts

@@ -0,0 +1,11 @@
+import type { EndpointNumber } from '@matter/types/datatype';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type MediaPowerSourceType } from './mediaHelpers.js';
+export interface VideoRemoteControlOptions {
+    powerSourceType?: MediaPowerSourceType;
+    id?: string;
+    number?: EndpointNumber;
+}
+export declare class VideoRemoteControl extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: VideoRemoteControlOptions);
+}

package/dist/devices/videoRemoteControl.js

@@ -0,0 +1,18 @@
+import { KeypadInput } from '@matter/types/clusters/keypad-input';
+import { MediaPlayback } from '@matter/types/clusters/media-playback';
+import { OnOff } from '@matter/types/clusters/on-off';
+import { powerSource, videoRemoteControl } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createDefaultMediaBindingClusterServer, createDefaultMediaPowerSourceClusterServer } from './mediaHelpers.js';
+export class VideoRemoteControl extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { powerSourceType = 'Battery' } = options;
+        super(powerSourceType === 'None' ? [videoRemoteControl] : [videoRemoteControl, powerSource], {
+            id: options.id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number: options.number,
+        });
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Video Remote Control');
+        createDefaultMediaPowerSourceClusterServer(this, powerSourceType);
+        createDefaultMediaBindingClusterServer(this, [OnOff.id, MediaPlayback.id, KeypadInput.id]);
+    }
+}

package/dist/frontend.js

@@ -1158,6 +1158,8 @@ export class Frontend extends EventEmitter {
                 attributes += `State: ${getEnumDescription(ValveConfigurationAndControl.ValveState, attributeValue, { fallback: 'unknown' })} `;
             if (clusterName === 'levelControl' && attributeName === 'currentLevel')
                 attributes += `Level: ${attributeValue} `;
+            if (clusterName === 'applicationBasic' && attributeName === 'applicationName')
+                attributes += `App: ${attributeValue} `;
             if (clusterName === 'colorControl' && attributeName === 'colorMode' && isValidNumber(attributeValue, 0, 2))
                 attributes += `Mode: ${['HS', 'XY', 'CT'][attributeValue]} `;
             if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 0 && attributeName === 'currentHue' && isValidNumber(attributeValue))

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -1,6 +1,7 @@
 import type { ActionContext } from '@matter/main';
 import type { ClusterType } from '@matter/types/cluster';
 import type { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
+import type { ApplicationLauncher } from '@matter/types/clusters/application-launcher';
 import type { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
 import type { ColorControl } from '@matter/types/clusters/color-control';
 import type { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
@@ -868,6 +869,27 @@ export type CommandHandlerDataMap = {
         attributes: {};
         endpoint: MatterbridgeEndpoint;
     };
+    'ApplicationLauncher.launchApp': {
+        command: 'launchApp';
+        request: ApplicationLauncher.LaunchAppRequest;
+        cluster: 'applicationLauncher';
+        attributes: ClusterAttributeValues<(typeof ApplicationLauncher)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'ApplicationLauncher.stopApp': {
+        command: 'stopApp';
+        request: ApplicationLauncher.StopAppRequest;
+        cluster: 'applicationLauncher';
+        attributes: ClusterAttributeValues<(typeof ApplicationLauncher)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'ApplicationLauncher.hideApp': {
+        command: 'hideApp';
+        request: ApplicationLauncher.HideAppRequest;
+        cluster: 'applicationLauncher';
+        attributes: ClusterAttributeValues<(typeof ApplicationLauncher)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'resetCondition': CommandHandlerData<'ResourceMonitoring.resetCondition'>;
     'ResourceMonitoring.resetCondition': {
         command: 'resetCondition';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.6-dev-20260820-36b52be",
+  "version": "3.10.6-dev-20260821-16f33ac",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,10 +132,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.6-dev-20260820-36b52be",
-    "@matterbridge/thread": "3.10.6-dev-20260820-36b52be",
-    "@matterbridge/types": "3.10.6-dev-20260820-36b52be",
-    "@matterbridge/utils": "3.10.6-dev-20260820-36b52be",
+    "@matterbridge/dgram": "3.10.6-dev-20260821-16f33ac",
+    "@matterbridge/thread": "3.10.6-dev-20260821-16f33ac",
+    "@matterbridge/types": "3.10.6-dev-20260821-16f33ac",
+    "@matterbridge/utils": "3.10.6-dev-20260821-16f33ac",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.2",