@matterbridge/core 3.10.9-dev-20260907-5fcc59a → 3.10.9-dev-20260910-ca91bcb

package/dist/devices/camera.js

@@ -0,0 +1,64 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import { createDefaultCameraAvSettingsUserLevelManagementClusterServer } from '../behaviors/cameraAvSettingsUserLevelManagementServer.js';
+import { createDefaultCameraAvStreamManagementClusterServer } from '../behaviors/cameraAvStreamManagementServer.js';
+import { addWebRtcTransportRequestorClient } from '../behaviors/clients.js';
+import { createDefaultWebRtcTransportProviderClusterServer } from '../behaviors/webRtcTransportProviderServer.js';
+import { camera, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class Camera extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', ptz = false, maxContentBufferSize = 4_194_304, maxNetworkBandwidth = 10_000_000, supportedStreamUsages = [StreamUsage.LiveView, StreamUsage.Recording], streamUsagePriorities = supportedStreamUsages, maxConcurrentEncoders = 1, maxEncodedPixelRate = 1920 * 1080 * 60, videoSensorParams = { sensorWidth: 1920, sensorHeight: 1080, maxFps: 60 }, minViewportResolution = { width: 640, height: 360 }, rateDistortionTradeOffPoints = [
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 640, height: 480 }, minBitRate: 250_000 },
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 1280, height: 720 }, minBitRate: 500_000 },
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 1920, height: 1080 }, minBitRate: 1_000_000 },
+        ], currentFrameRate = 30, viewport = { x1: 0, y1: 0, x2: videoSensorParams.sensorWidth, y2: videoSensorParams.sensorHeight }, microphoneCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, snapshotCapabilities = [
+            { resolution: { width: 640, height: 480 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+            { resolution: { width: 1280, height: 720 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+            { resolution: { width: 1920, height: 1080 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+        ], panMin = -170, panMax = 170, tiltMin = -20, tiltMax = 90, zoomMax = 10, mptzPosition = { pan: 0, tilt: 0, zoom: 1 }, weriftOfferOptions, id, number, tagList, mode, } = options;
+        super(powerSourceType === 'None' ? [camera] : [camera, powerSource], { id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, number, tagList, mode });
+        if (identifyType !== Identify.IdentifyType.None) {
+            this.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        }
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Chime');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Camera');
+        createDefaultCameraAvStreamManagementClusterServer(this, {
+            maxContentBufferSize,
+            maxNetworkBandwidth,
+            supportedStreamUsages,
+            streamUsagePriorities,
+            maxConcurrentEncoders,
+            maxEncodedPixelRate,
+            videoSensorParams,
+            minViewportResolution,
+            rateDistortionTradeOffPoints,
+            currentFrameRate,
+            viewport,
+            microphoneCapabilities,
+            snapshotCapabilities,
+        });
+        if (ptz)
+            createDefaultCameraAvSettingsUserLevelManagementClusterServer(this, { panMin, panMax, tiltMin, tiltMax, zoomMax, mptzPosition });
+        createDefaultWebRtcTransportProviderClusterServer(this, weriftOfferOptions);
+        addWebRtcTransportRequestorClient(this);
+        this.addRequiredClusters();
+    }
+}

package/dist/devices/chime.d.ts

@@ -0,0 +1,16 @@
+import type { Chime as ChimeCluster } from '@matter/types/clusters/chime';
+import { Identify } from '@matter/types/clusters/identify';
+import { type ChimeId } from '../behaviors/chimeServer.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+export interface ChimeOptions extends MatterbridgeEndpointOptions {
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+    installedChimeSounds?: ChimeCluster.ChimeSound[];
+    selectedChime?: ChimeId;
+    enabled?: boolean;
+}
+export declare class Chime extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: ChimeOptions);
+}

package/dist/devices/chime.js

@@ -0,0 +1,37 @@
+import { Identify } from '@matter/types/clusters/identify';
+import { createDefaultChimeClusterServer } from '../behaviors/chimeServer.js';
+import { chime, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class Chime extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', installedChimeSounds = [
+            {
+                chimeId: 0,
+                name: 'Default Chime',
+            },
+        ], selectedChime = 0, enabled = true, id, number, tagList, mode, } = options;
+        super(powerSourceType === 'None' ? [chime] : [chime, powerSource], { id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, number, tagList, mode });
+        if (identifyType !== Identify.IdentifyType.None) {
+            this.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        }
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Chime');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
+        createDefaultChimeClusterServer(this, installedChimeSounds, selectedChime, enabled);
+        this.addRequiredClusters();
+    }
+}

package/dist/devices/doorbell.d.ts

@@ -0,0 +1,11 @@
+import { Identify } from '@matter/types/clusters/identify';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+export interface DoorbellOptions extends MatterbridgeEndpointOptions {
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+}
+export declare class Doorbell extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: DoorbellOptions);
+}

package/dist/devices/doorbell.js

@@ -0,0 +1,31 @@
+import { Identify } from '@matter/types/clusters/identify';
+import { addChimeClient } from '../behaviors/clients.js';
+import { doorbell, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class Doorbell extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', id, number, tagList, mode } = options;
+        super(powerSourceType === 'None' ? [doorbell] : [doorbell, powerSource], { id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, number, tagList, mode });
+        this.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Doorbell');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
+        this.createDefaultMomentarySwitchClusterServer();
+        addChimeClient(this);
+        this.addRequiredClusters();
+    }
+}

package/dist/devices/floodlightCamera.d.ts

@@ -0,0 +1,19 @@
+import type { Semtag } from '@matter/types';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+import type { CameraOptions } from './camera.js';
+export type FloodlightCameraCameraOptions = Omit<CameraOptions, 'id' | 'number' | 'tagList' | 'mode' | 'powerSourceType'>;
+export interface FloodlightCameraLightOptions {
+    name?: string;
+    tagList?: Semtag[];
+    onOff?: boolean;
+}
+export interface FloodlightCameraOptions extends MatterbridgeEndpointOptions {
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+    cameraOptions?: FloodlightCameraCameraOptions;
+    lightOptions?: FloodlightCameraLightOptions;
+}
+export declare class FloodlightCamera extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: FloodlightCameraOptions);
+    addLight(name: string, tagList?: Semtag[], onOff?: boolean): MatterbridgeEndpoint;
+}

package/dist/devices/floodlightCamera.js

@@ -0,0 +1,81 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import { fireAndForget } from '@matterbridge/utils';
+import { createDefaultCameraAvStreamManagementClusterServer } from '../behaviors/cameraAvStreamManagementServer.js';
+import { addWebRtcTransportRequestorClient } from '../behaviors/clients.js';
+import { createDefaultWebRtcTransportProviderClusterServer } from '../behaviors/webRtcTransportProviderServer.js';
+import { camera, floodlightCamera, onOffLight, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class FloodlightCamera extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { powerSourceType = 'Wired', cameraOptions = {}, lightOptions = {}, id, number, tagList, mode } = options;
+        super(powerSourceType === 'None' ? [floodlightCamera] : [floodlightCamera, powerSource], {
+            id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number,
+            tagList,
+            mode,
+        });
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Floodlight Camera');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
+        fireAndForget(this.addFixedLabel('composed', 'FloodlightCamera'), this.log, 'Error adding composed label to floodlight camera');
+        this.addRequiredClusters();
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, maxContentBufferSize = 4_194_304, maxNetworkBandwidth = 10_000_000, supportedStreamUsages = [StreamUsage.LiveView, StreamUsage.Recording], streamUsagePriorities = supportedStreamUsages, maxConcurrentEncoders = 1, maxEncodedPixelRate = 1920 * 1080 * 60, videoSensorParams = { sensorWidth: 1920, sensorHeight: 1080, maxFps: 60 }, minViewportResolution = { width: 640, height: 360 }, rateDistortionTradeOffPoints = [
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 640, height: 480 }, minBitRate: 250_000 },
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 1280, height: 720 }, minBitRate: 500_000 },
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 1920, height: 1080 }, minBitRate: 1_000_000 },
+        ], currentFrameRate = 30, viewport = { x1: 0, y1: 0, x2: videoSensorParams.sensorWidth, y2: videoSensorParams.sensorHeight }, microphoneCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, snapshotCapabilities = [
+            { resolution: { width: 640, height: 480 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+            { resolution: { width: 1280, height: 720 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+            { resolution: { width: 1920, height: 1080 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+        ], weriftOfferOptions, } = cameraOptions;
+        const cameraChild = this.addChildDeviceType('Camera', camera, {});
+        cameraChild.log.logName = 'Camera';
+        if (identifyType !== Identify.IdentifyType.None) {
+            cameraChild.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        }
+        createDefaultCameraAvStreamManagementClusterServer(cameraChild, {
+            maxContentBufferSize,
+            maxNetworkBandwidth,
+            supportedStreamUsages,
+            streamUsagePriorities,
+            maxConcurrentEncoders,
+            maxEncodedPixelRate,
+            videoSensorParams,
+            minViewportResolution,
+            rateDistortionTradeOffPoints,
+            currentFrameRate,
+            viewport,
+            microphoneCapabilities,
+            snapshotCapabilities,
+        });
+        createDefaultWebRtcTransportProviderClusterServer(cameraChild, weriftOfferOptions);
+        addWebRtcTransportRequestorClient(cameraChild);
+        cameraChild.addRequiredClusters();
+        const { name: lightName = 'Light', tagList: lightTagList = [], onOff: lightOnOff = false } = lightOptions;
+        this.addLight(lightName, lightTagList, lightOnOff);
+    }
+    addLight(name, tagList = [], onOff = false) {
+        const light = this.addChildDeviceType(name, onOffLight, tagList.length > 0 ? { tagList } : {});
+        light.log.logName = name;
+        light.createDefaultIdentifyClusterServer();
+        light.createDefaultOnOffClusterServer(onOff);
+        light.addRequiredClusters();
+        return light;
+    }
+}

package/dist/devices/intercom.d.ts

@@ -0,0 +1,22 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import type { WeriftOfferOptions } from '../behaviors/weriftSession.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+export interface IntercomOptions extends MatterbridgeEndpointOptions {
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+    maxContentBufferSize?: number;
+    maxNetworkBandwidth?: number;
+    supportedStreamUsages?: StreamUsage[];
+    streamUsagePriorities?: StreamUsage[];
+    microphoneCapabilities?: CameraAvStreamManagement.AudioCapabilities;
+    speakerCapabilities?: CameraAvStreamManagement.AudioCapabilities;
+    twoWayTalkSupport?: CameraAvStreamManagement.TwoWayTalkSupportType;
+    weriftOfferOptions?: WeriftOfferOptions;
+}
+export declare class Intercom extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: IntercomOptions);
+}

package/dist/devices/intercom.js

@@ -0,0 +1,55 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import { createDefaultIntercomCameraAvStreamManagementClusterServer } from '../behaviors/cameraAvStreamManagementServer.js';
+import { addChimeClient, addWebRtcTransportProviderClient, addWebRtcTransportRequestorClient } from '../behaviors/clients.js';
+import { createDefaultWebRtcTransportProviderClusterServer } from '../behaviors/webRtcTransportProviderServer.js';
+import { createDefaultWebRtcTransportRequestorClusterServer } from '../behaviors/webRtcTransportRequestorServer.js';
+import { intercom, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class Intercom extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', maxContentBufferSize = 65_536, maxNetworkBandwidth = 128_000, supportedStreamUsages = [StreamUsage.LiveView], streamUsagePriorities = supportedStreamUsages, microphoneCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, speakerCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, twoWayTalkSupport = CameraAvStreamManagement.TwoWayTalkSupportType.FullDuplex, weriftOfferOptions, id, number, tagList, mode, } = options;
+        super(powerSourceType === 'None' ? [intercom] : [intercom, powerSource], {
+            id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number,
+            tagList,
+            mode,
+        });
+        if (identifyType !== Identify.IdentifyType.None) {
+            this.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        }
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Intercom');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
+        createDefaultIntercomCameraAvStreamManagementClusterServer(this, {
+            maxContentBufferSize,
+            maxNetworkBandwidth,
+            supportedStreamUsages,
+            streamUsagePriorities,
+            microphoneCapabilities,
+            speakerCapabilities,
+            twoWayTalkSupport,
+        });
+        createDefaultWebRtcTransportProviderClusterServer(this, weriftOfferOptions);
+        createDefaultWebRtcTransportRequestorClusterServer(this);
+        addWebRtcTransportProviderClient(this);
+        addWebRtcTransportRequestorClient(this);
+        addChimeClient(this);
+        this.addRequiredClusters();
+    }
+}

package/dist/devices/snapshotCamera.d.ts

@@ -0,0 +1,20 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+export interface SnapshotCameraOptions extends MatterbridgeEndpointOptions {
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+    maxConcurrentEncoders?: number;
+    maxEncodedPixelRate?: number;
+    maxContentBufferSize?: number;
+    snapshotCapabilities?: CameraAvStreamManagement.SnapshotCapabilities[];
+    maxNetworkBandwidth?: number;
+    supportedStreamUsages?: StreamUsage[];
+    streamUsagePriorities?: StreamUsage[];
+}
+export declare class SnapshotCamera extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: SnapshotCameraOptions);
+}

package/dist/devices/snapshotCamera.js

@@ -0,0 +1,51 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import { createDefaultSnapshotCameraAvStreamManagementClusterServer } from '../behaviors/cameraAvStreamManagementServer.js';
+import { powerSource, snapshotCamera } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class SnapshotCamera extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', maxConcurrentEncoders = 1, maxEncodedPixelRate = 10000000, maxContentBufferSize = 1024, snapshotCapabilities = [
+            { resolution: { width: 640, height: 480 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+            { resolution: { width: 1280, height: 720 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+            { resolution: { width: 1920, height: 1080 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+        ], maxNetworkBandwidth = 10000, supportedStreamUsages = [StreamUsage.Recording], streamUsagePriorities = [StreamUsage.Recording], id, number, tagList, mode, } = options;
+        super(powerSourceType === 'None' ? [snapshotCamera] : [snapshotCamera, powerSource], {
+            id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number,
+            tagList,
+            mode,
+        });
+        if (identifyType !== Identify.IdentifyType.None) {
+            this.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        }
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Snapshot Camera');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
+        createDefaultSnapshotCameraAvStreamManagementClusterServer(this, {
+            maxConcurrentEncoders,
+            maxEncodedPixelRate,
+            maxContentBufferSize,
+            snapshotCapabilities,
+            maxNetworkBandwidth,
+            supportedStreamUsages,
+            streamUsagePriorities,
+        });
+        this.addRequiredClusters();
+    }
+}

package/dist/devices/videoDoorbell.d.ts

@@ -0,0 +1,21 @@
+import type { Semtag } from '@matter/types';
+import { Identify } from '@matter/types/clusters/identify';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+import type { CameraOptions } from './camera.js';
+export type VideoDoorbellCameraOptions = Omit<CameraOptions, 'id' | 'number' | 'tagList' | 'mode' | 'powerSourceType'>;
+export interface VideoDoorbellDoorbellOptions {
+    name?: string;
+    tagList?: Semtag[];
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+}
+export interface VideoDoorbellOptions extends MatterbridgeEndpointOptions {
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+    cameraOptions?: VideoDoorbellCameraOptions;
+    doorbellOptions?: VideoDoorbellDoorbellOptions;
+}
+export declare class VideoDoorbell extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: VideoDoorbellOptions);
+    addDoorbell(name: string, tagList?: Semtag[], identifyTime?: number, identifyType?: Identify.IdentifyType): MatterbridgeEndpoint;
+}

package/dist/devices/videoDoorbell.js

@@ -0,0 +1,82 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import { fireAndForget } from '@matterbridge/utils';
+import { createDefaultCameraAvStreamManagementClusterServer } from '../behaviors/cameraAvStreamManagementServer.js';
+import { addChimeClient, addWebRtcTransportRequestorClient } from '../behaviors/clients.js';
+import { createDefaultWebRtcTransportProviderClusterServer } from '../behaviors/webRtcTransportProviderServer.js';
+import { camera, doorbell, powerSource, videoDoorbell } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class VideoDoorbell extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { powerSourceType = 'Wired', cameraOptions = {}, doorbellOptions = {}, id, number, tagList, mode } = options;
+        super(powerSourceType === 'None' ? [videoDoorbell] : [videoDoorbell, powerSource], {
+            id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number,
+            tagList,
+            mode,
+        });
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Video Doorbell');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
+        fireAndForget(this.addFixedLabel('composed', 'VideoDoorbell'), this.log, 'Error adding composed label to video doorbell');
+        this.addRequiredClusters();
+        const { identifyTime: cameraIdentifyTime = 0, identifyType: cameraIdentifyType = Identify.IdentifyType.None, maxContentBufferSize = 4_194_304, maxNetworkBandwidth = 10_000_000, supportedStreamUsages = [StreamUsage.LiveView, StreamUsage.Recording], streamUsagePriorities = supportedStreamUsages, maxConcurrentEncoders = 1, maxEncodedPixelRate = 1920 * 1080 * 60, videoSensorParams = { sensorWidth: 1920, sensorHeight: 1080, maxFps: 60 }, minViewportResolution = { width: 640, height: 360 }, rateDistortionTradeOffPoints = [
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 640, height: 480 }, minBitRate: 250_000 },
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 1280, height: 720 }, minBitRate: 500_000 },
+            { codec: CameraAvStreamManagement.VideoCodec.H264, resolution: { width: 1920, height: 1080 }, minBitRate: 1_000_000 },
+        ], currentFrameRate = 30, viewport = { x1: 0, y1: 0, x2: videoSensorParams.sensorWidth, y2: videoSensorParams.sensorHeight }, microphoneCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, snapshotCapabilities = [
+            { resolution: { width: 640, height: 480 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+            { resolution: { width: 1280, height: 720 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+            { resolution: { width: 1920, height: 1080 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
+        ], weriftOfferOptions, } = cameraOptions;
+        const cameraChild = this.addChildDeviceType('Camera', camera, {});
+        cameraChild.log.logName = 'Camera';
+        if (cameraIdentifyType !== Identify.IdentifyType.None) {
+            cameraChild.createDefaultIdentifyClusterServer(cameraIdentifyTime, cameraIdentifyType);
+        }
+        createDefaultCameraAvStreamManagementClusterServer(cameraChild, {
+            maxContentBufferSize,
+            maxNetworkBandwidth,
+            supportedStreamUsages,
+            streamUsagePriorities,
+            maxConcurrentEncoders,
+            maxEncodedPixelRate,
+            videoSensorParams,
+            minViewportResolution,
+            rateDistortionTradeOffPoints,
+            currentFrameRate,
+            viewport,
+            microphoneCapabilities,
+            snapshotCapabilities,
+        });
+        createDefaultWebRtcTransportProviderClusterServer(cameraChild, weriftOfferOptions);
+        addWebRtcTransportRequestorClient(cameraChild);
+        cameraChild.addRequiredClusters();
+        const { name: doorbellName = 'Doorbell', tagList: doorbellTagList = [], identifyTime = 0, identifyType = Identify.IdentifyType.None } = doorbellOptions;
+        this.addDoorbell(doorbellName, doorbellTagList, identifyTime, identifyType);
+    }
+    addDoorbell(name, tagList = [], identifyTime = 0, identifyType = Identify.IdentifyType.None) {
+        const doorbellChild = this.addChildDeviceType(name, doorbell, tagList.length > 0 ? { tagList } : {});
+        doorbellChild.log.logName = name;
+        doorbellChild.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        doorbellChild.createDefaultMomentarySwitchClusterServer();
+        addChimeClient(doorbellChild);
+        doorbellChild.addRequiredClusters();
+        return doorbellChild;
+    }
+}

package/dist/matterbridgeEndpoint.d.ts

@@ -28,7 +28,7 @@ import type { MeasurementAccuracy, Semtag } from '@matter/types/globals';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
 import type { DeviceTypeDefinition } from './matterbridgeDeviceTypes.js';
 import { CommandHandler, type CommandHandlerData, type CommandHandlerExecutionResult, type CommandHandlerFunction, type CommandHandlers } from './matterbridgeEndpointCommandHandler.js';
-import type { MatterbridgeEndpointOptions, SerializedMatterbridgeEndpoint } from './matterbridgeEndpointTypes.js';
+import type { MatterbridgeEndpointOptions, SerializedMatterbridgeEndpoint, SubscribeCommandListener } from './matterbridgeEndpointTypes.js';
 type FirstCommandParam<Params extends unknown[]> = Params extends [] ? undefined : Params[0];
 type BehaviorCluster<T extends Behavior.Type> = T extends {
     cluster: infer C extends ClusterType;
@@ -106,6 +106,9 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     subscribeAttribute<T extends Behavior.Type, A extends keyof Behavior.StateOf<T>>(cluster: T, attribute: A, listener: (newValue: Behavior.StateOf<T>[A], oldValue: Behavior.StateOf<T>[A], context: ActionContext) => void, log?: AnsiLogger): MatterbridgeEndpoint;
     subscribeAttribute<T extends ClusterType, A extends keyof ClusterAttributesOf<T>>(cluster: T, attribute: A, listener: (newValue: ClusterAttributesOf<T>[A], oldValue: ClusterAttributesOf<T>[A], context: ActionContext) => void, log?: AnsiLogger): MatterbridgeEndpoint;
     subscribeAttribute(cluster: ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): MatterbridgeEndpoint;
+    subscribeCommand<T extends Behavior.Type, C extends BehaviorCommandName<T>>(cluster: T, command: C, listener: SubscribeCommandListener<BehaviorCommandParams<T, C>>, log?: AnsiLogger): MatterbridgeEndpoint;
+    subscribeCommand<T extends ClusterType, C extends ClusterCommandName<T>>(cluster: T, command: C, listener: SubscribeCommandListener<ClusterCommandParams<T, C>>, log?: AnsiLogger): MatterbridgeEndpoint;
+    subscribeCommand(cluster: ClusterId | string, command: string, listener: SubscribeCommandListener, log?: AnsiLogger): MatterbridgeEndpoint;
     setCluster<T extends Behavior.Type>(cluster: T, value: Behavior.StateOf<T>, log?: AnsiLogger): Promise<boolean>;
     setCluster<T extends ClusterType>(cluster: T, value: Partial<ClusterAttributesOf<T>>, log?: AnsiLogger): Promise<boolean>;
     setCluster(cluster: ClusterId | string, value: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;

package/dist/matterbridgeEndpoint.js

@@ -85,7 +85,7 @@ import { MatterbridgeValveConfigurationAndControlServer } from './behaviors/valv
 import { MatterbridgeWaterTankLevelMonitoringServer } from './behaviors/waterTankLevelMonitoringServer.js';
 import { MatterbridgeWindowCoveringServer } from './behaviors/windowCoveringServer.js';
 import { CommandHandler, } from './matterbridgeEndpointCommandHandler.js';
-import { addClusterClients, addClusterServers, addFixedLabel, addOptionalClusterClients, addOptionalClusterServers, addRequiredClusterClients, addRequiredClusterServers, addUserLabel, checkNotLatinCharacters, createUniqueId, defaultFor, featuresFor, generateUniqueId, getApparentElectricalPowerMeasurementClusterServer, getAttribute, getAttributeId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getCluster, getClusterId, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultOperationalStateClusterServer, getDefaultPowerSourceBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceWiredClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultSoilMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getExportedElectricalEnergyMeasurementClusterServer, getImportedElectricalEnergyMeasurementClusterServer, invokeBehaviorCommand, lowercaseFirstLetter, setAttribute, setCluster, subscribeAttribute, triggerEvent, updateAttribute, } from './matterbridgeEndpointHelpers.js';
+import { addClusterClients, addClusterServers, addFixedLabel, addOptionalClusterClients, addOptionalClusterServers, addRequiredClusterClients, addRequiredClusterServers, addUserLabel, checkNotLatinCharacters, createUniqueId, defaultFor, featuresFor, generateUniqueId, getApparentElectricalPowerMeasurementClusterServer, getAttribute, getAttributeId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getCluster, getClusterId, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultOperationalStateClusterServer, getDefaultPowerSourceBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceWiredClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultSoilMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getExportedElectricalEnergyMeasurementClusterServer, getImportedElectricalEnergyMeasurementClusterServer, invokeBehaviorCommand, lowercaseFirstLetter, setAttribute, setCluster, subscribeAttribute, subscribeCommand, triggerEvent, updateAttribute, } from './matterbridgeEndpointHelpers.js';
 logModuleLoaded('MatterbridgeEndpoint');
 const MATTERBRIDGE_ENDPOINT_BRAND = Symbol('MatterbridgeEndpoint.brand');
 export function isMatterbridgeEndpoint(value) {
@@ -251,6 +251,9 @@ export class MatterbridgeEndpoint extends Endpoint {
     subscribeAttribute(cluster, attribute, listener, log) {
         return subscribeAttribute(this, cluster, attribute, listener, log);
     }
+    subscribeCommand(cluster, command, listener, log) {
+        return subscribeCommand(this, cluster, command, listener, log);
+    }
     async setCluster(cluster, value, log) {
         return await setCluster(this, cluster, value, log);
     }

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -24,6 +24,7 @@ import { MatterbridgeOperationalStateServer } from './behaviors/operationalState
 import { MatterbridgePowerSourceServer } from './behaviors/powerSourceServer.js';
 import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import type { CommandHandlers } from './matterbridgeEndpointCommandHandler.js';
+import type { SubscribeCommandListener } from './matterbridgeEndpointTypes.js';
 export declare function capitalizeFirstLetter(name: string): string;
 export declare function lowercaseFirstLetter(name: string): string;
 export declare function getSnapshot<T>(value: T): T;
@@ -57,6 +58,8 @@ export declare function getAttribute(endpoint: MatterbridgeEndpoint, cluster: Be
 export declare function setAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
 export declare function updateAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
 export declare function subscribeAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): MatterbridgeEndpoint;
+export declare function subscribeCommand(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, command: string, listener: SubscribeCommandListener, log?: AnsiLogger): MatterbridgeEndpoint;
+export declare function emitCommand(endpoint: Endpoint, cluster: string, command: string, request: unknown, context: ActionContext): void;
 export declare function setCluster(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, value: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;
 export declare function getCluster(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, log?: AnsiLogger): Record<string, boolean | number | bigint | string | object | undefined | null> | undefined;
 export declare function triggerEvent(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, event: string, payload: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;