@matter/node 0.17.4 → 0.17.5-alpha.0-20260702-a2cd6f764

package/src/behaviors/groups/GroupsServer.ts

@@ -11,7 +11,7 @@ import { Endpoint } from "#endpoint/Endpoint.js";
 import { RootEndpoint } from "#endpoints/root";
 import { InternalError, Logger } from "@matter/general";
 import { assertRemoteActor, Fabric } from "@matter/protocol";
-import { Status, StatusResponseError } from "@matter/types";
+import { FabricIndex, Status, StatusResponseError } from "@matter/types";
 import { Groups } from "@matter/types/clusters/groups";
 import { GroupsBehavior } from "./GroupsBehavior.js";
 
@@ -81,6 +81,16 @@ export class GroupsServer extends GroupsBase {
         return act(this.context.session.associatedFabric, gkm);
     }
 
+    // Groups cluster rev 5: management commands return INVALID_IN_STATE for Groupcast-adopted fabrics.  Inert while
+    // the Groupcast feature is provisional (groupcastAdoption is never populated), guarded in GroupKeyManagementServer.
+    #isGroupcastAdopted(fabricIndex: FabricIndex): boolean {
+        const groupcastAdoption = this.#rootEndpoint.stateOf(GroupKeyManagementServer).groupcastAdoption;
+        if (!groupcastAdoption) {
+            return false;
+        }
+        return groupcastAdoption.some(e => e.fabricIndex === fabricIndex && e.groupcastAdopted);
+    }
+
     override async addGroup({ groupId, groupName }: Groups.AddGroupRequest): Promise<Groups.AddGroupResponse> {
         assertRemoteActor(this.context);
         const fabric = this.context.session.associatedFabric;
@@ -92,6 +102,10 @@ export class GroupsServer extends GroupsBase {
             return { status: Status.ConstraintError, groupId };
         }
 
+        if (this.#isGroupcastAdopted(fabric.fabricIndex)) {
+            return { status: Status.InvalidInState, groupId };
+        }
+
         if (!fabric.groups.groupKeyIdMap.has(groupId)) {
             return { status: Status.UnsupportedAccess, groupId };
         }
@@ -119,6 +133,10 @@ export class GroupsServer extends GroupsBase {
             return { status: Status.ConstraintError, groupId, groupName: "" };
         }
 
+        if (this.#isGroupcastAdopted(fabric.fabricIndex)) {
+            return { status: Status.InvalidInState, groupId, groupName: "" };
+        }
+
         const fabricIndex = fabric.fabricIndex;
         const endpointNumber = this.endpoint.number;
 
@@ -135,6 +153,11 @@ export class GroupsServer extends GroupsBase {
     }: Groups.GetGroupMembershipRequest): Promise<Groups.GetGroupMembershipResponse> {
         assertRemoteActor(this.context);
         const fabric = this.context.session.associatedFabric;
+
+        if (this.#isGroupcastAdopted(fabric.fabricIndex)) {
+            throw new StatusResponseError("Groupcast adopted, use Groupcast cluster", Status.InvalidInState);
+        }
+
         const fabricIndex = fabric.fabricIndex;
         const endpointNumber = this.endpoint.number;
 
@@ -194,6 +217,10 @@ export class GroupsServer extends GroupsBase {
     }
 
     override async addGroupIfIdentifying({ groupId, groupName }: Groups.AddGroupIfIdentifyingRequest) {
+        assertRemoteActor(this.context);
+        if (this.#isGroupcastAdopted(this.context.session.associatedFabric.fabricIndex)) {
+            throw new StatusResponseError("Groupcast adopted, use Groupcast cluster", Status.InvalidInState);
+        }
         if (this.endpoint.stateOf(IdentifyBehavior).identifyTime > 0) {
             // We identify ourselves currently
             const { status } = await this.addGroup({ groupId, groupName });

package/src/behaviors/index.ts

@@ -13,6 +13,7 @@ export * from "./activated-carbon-filter-monitoring/index.js";
 export * from "./administrator-commissioning/index.js";
 export * from "./air-quality/index.js";
 export * from "./alarm-base/index.js";
+export * from "./ambient-context-sensing/index.js";
 export * from "./application-basic/index.js";
 export * from "./application-launcher/index.js";
 export * from "./audio-output/index.js";
@@ -60,6 +61,7 @@ export * from "./formaldehyde-concentration-measurement/index.js";
 export * from "./general-commissioning/index.js";
 export * from "./general-diagnostics/index.js";
 export * from "./group-key-management/index.js";
+export * from "./groupcast/index.js";
 export * from "./groups/index.js";
 export * from "./hepa-filter-monitoring/index.js";
 export * from "./icd-management/index.js";
@@ -118,6 +120,7 @@ export * from "./software-diagnostics/index.js";
 export * from "./soil-measurement/index.js";
 export * from "./switch/index.js";
 export * from "./target-navigator/index.js";
+export * from "./temperature-alarm/index.js";
 export * from "./temperature-control/index.js";
 export * from "./temperature-measurement/index.js";
 export * from "./thermostat/index.js";

package/src/behaviors/level-control/LevelControlServer.ts

@@ -559,7 +559,7 @@ export class LevelControlBaseServer extends LevelControlBase {
      *
      * By default we set the current level to the onLevel value when the device is turned on.
      *
-     * Other fading up/down logic required by the {@link MatterSpecification.v12.Cluster} §1.6.4.1.1 needs to be
+     * Other fading up/down logic required by the {@link MatterSpecification.v16.Cluster} §1.6.4.1.1 needs to be
      * implemented in a specialized implementation if needed.
      *
      * @param onOff The new onOff state

package/src/behaviors/occupancy-sensing/OccupancySensingServer.ts

@@ -16,6 +16,7 @@ const logger = Logger.get("OccupancySensingServer");
  *
  * The Matter specification requires the OccupancySensing cluster to support features we do not enable by default. You
  * should use {@link OccupancySensingServer.with} to specialize the class for the features your implementation supports.
+ * When the OccupancyEvent feature is enabled the OccupancyChanged event is emitted automatically on occupancy change.
  */
 export class OccupancySensingServer extends OccupancySensingBehavior {
     override initialize(): MaybePromise {
@@ -63,8 +64,15 @@ export class OccupancySensingServer extends OccupancySensingBehavior {
             }
         }
 
-        // Clear attributes that are dependent on HoldTime if HoldTime is not set.
-        // TODO - if we instead avoid defaults for attributes with field-conditional conformance, remove this
+        // Emit the OccupancyChanged event on occupancy change when the feature is enabled
+        if (this.features.occupancyEvent) {
+            this.reactTo(this.events.occupancy$Changed, this.#emitOccupancyChanged);
+        } else {
+            logger.info(
+                'OccupancySensingServer: enable the OccupancyEvent feature (e.g. OccupancySensingServer.with("<DetectorType>", "OccupancyEvent")) to emit the OccupancyChanged event.',
+            );
+        }
+
         // Clear attributes that are dependent on HoldTime if HoldTime is not set.
         // TODO - if we instead avoid defaults for attributes with field-conditional conformance, remove this
         if (this.state.holdTime === undefined) {
@@ -76,6 +84,10 @@ export class OccupancySensingServer extends OccupancySensingBehavior {
             }
         }
     }
+
+    #emitOccupancyChanged(occupancy: OccupancySensing.Occupancy) {
+        this.events.occupancyChanged?.emit({ occupancy }, this.context);
+    }
 }
 
 const holdTimeDependencies = [

package/src/behaviors/operational-credentials/VendorIdVerification.ts

@@ -96,7 +96,7 @@ export namespace VendorIdVerification {
      * It requires data read the the device (if relevant read non fabric filtered) for fabrics, nocs and
      * trustedRootCertificates to provide the raw input data for verification.
      *
-     * @see {@link MatterSpecification.v142.Cluster} § 6.4.10.1.
+     * @see {@link MatterSpecification.v16.Core} § 6.4.10.1.
      */
     export async function verify(
         node: ClientNode,
@@ -163,7 +163,7 @@ export namespace VendorIdVerification {
     /**
      * Verify VendorId ownership using VID Verification protocol on pure data level
      *
-     * @see {@link MatterSpecification.v142.Cluster} § 6.4.10.1.
+     * @see {@link MatterSpecification.v16.Core} § 6.4.10.1.
      */
     export async function verifyData(
         crypto: Crypto,

package/src/behaviors/ota-software-update-provider/OtaSoftwareUpdateProviderServer.ts

@@ -110,7 +110,7 @@ export class OtaSoftwareUpdateProviderServer extends OtaSoftwareUpdateProviderBe
         if (!ownFabric) {
             // Can only happen if the SoftwareUpdateManager is used without any commissioned nodes
             logger.info(`No owning fabric, delay initialization`);
-            fabricAuthority.fabricAdded.once(() => this.#nodeOnline());
+            this.reactTo(fabricAuthority.fabricAdded, this.#nodeOnline, { once: true });
             return;
         }
 

package/src/behaviors/scenes-management/ScenesManagementServer.ts

@@ -185,7 +185,7 @@ export class ScenesManagementServer extends ScenesManagementBase {
         // Initialize fabric scene info field to match to the current state of the scene table
         this.#initializeFabricSceneInfo(fabricManager);
 
-        // When a fabric git removed we need to check if the active scene is considered from that fabric
+        // When a fabric got removed, we need to check if the active scene is considered from that fabric
         // Data cleanup happens automatically
         this.reactTo(fabricManager.events.deleting, this.#handleDeleteFabric);
     }

package/src/behaviors/temperature-alarm/TemperatureAlarmBehavior.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { TemperatureAlarm } from "@matter/types/clusters/temperature-alarm";
+import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { Identity } from "@matter/general";
+
+/**
+ * TemperatureAlarmBehavior is the base class for objects that support interaction with
+ * {@link TemperatureAlarm.Cluster}.
+ *
+ * TemperatureAlarm.Cluster requires you to enable one or more optional features. You can do so using
+ * {@link TemperatureAlarmBehavior.with}.
+ */
+export const TemperatureAlarmBehaviorConstructor = ClusterBehavior.for(TemperatureAlarm);
+
+export interface TemperatureAlarmBehaviorConstructor extends Identity<typeof TemperatureAlarmBehaviorConstructor> {}
+export const TemperatureAlarmBehavior: TemperatureAlarmBehaviorConstructor = TemperatureAlarmBehaviorConstructor;
+export interface TemperatureAlarmBehavior extends InstanceType<TemperatureAlarmBehaviorConstructor> {}
+export namespace TemperatureAlarmBehavior {
+    export interface State extends InstanceType<typeof TemperatureAlarmBehavior.State> {}
+}

package/src/behaviors/temperature-alarm/TemperatureAlarmClient.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { TemperatureAlarm } from "@matter/types/clusters/temperature-alarm";
+import { ClientBehavior } from "../../behavior/cluster/ClientBehavior.js";
+import { Identity } from "@matter/general";
+
+export const TemperatureAlarmClientConstructor = ClientBehavior(TemperatureAlarm);
+export interface TemperatureAlarmClient extends InstanceType<typeof TemperatureAlarmClientConstructor> {}
+export interface TemperatureAlarmClientConstructor extends Identity<typeof TemperatureAlarmClientConstructor> {}
+export const TemperatureAlarmClient: TemperatureAlarmClientConstructor = TemperatureAlarmClientConstructor;

package/src/behaviors/temperature-alarm/TemperatureAlarmServer.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
+
+import { TemperatureAlarmBehavior } from "./TemperatureAlarmBehavior.js";
+
+/**
+ * This is the default server implementation of {@link TemperatureAlarmBehavior}.
+ *
+ * The Matter specification requires the TemperatureAlarm cluster to support features we do not enable by default. You
+ * should use {@link TemperatureAlarmServer.with} to specialize the class for the features your implementation supports.
+ */
+export class TemperatureAlarmServer extends TemperatureAlarmBehavior {}

package/src/behaviors/temperature-alarm/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
+
+export * from "./TemperatureAlarmBehavior.js";
+export * from "./TemperatureAlarmServer.js";
+export * from "./TemperatureAlarmClient.js";

package/src/behaviors/web-rtc-transport-requestor/WebRtcTransportRequestorServer.ts

@@ -4,11 +4,191 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
-
+import { AccessControlServer } from "#behaviors/access-control";
+import { Node } from "#node/Node.js";
+import type { ServerNode } from "#node/ServerNode.js";
+import { Logger, Observable } from "@matter/general";
+import { assertRemoteActor, FabricAuthority, NodeSession } from "@matter/protocol";
+import { Status, StatusResponseError } from "@matter/types";
+import { AccessControl } from "@matter/types/clusters/access-control";
+import { WebRtcTransportDefinitions } from "@matter/types/clusters/web-rtc-transport-definitions";
+import { WebRtcTransportRequestor } from "@matter/types/clusters/web-rtc-transport-requestor";
 import { WebRtcTransportRequestorBehavior } from "./WebRtcTransportRequestorBehavior.js";
 
+type WebRtcSession = WebRtcTransportDefinitions.WebRtcSession;
+
+const logger = Logger.get("WebRtcTransportRequestorServer");
+
 /**
  * This is the default server implementation of {@link WebRtcTransportRequestorBehavior}.
+ *
+ * This cluster lives on the controller side of a WebRTC stream (e.g. a camera controller). The peer camera/provider
+ * drives signaling by invoking the Offer, Answer, IceCandidates and End commands on this cluster. The default
+ * implementation validates each command against the session's originating fabric and peer node, tracks live sessions in
+ * the `currentSessions` attribute, and re-emits the signaling through the {@link WebRtcTransportRequestorServer.Events}
+ * observables so you can drive your own WebRTC peer connection.
+ *
+ * To use it:
+ * * Register a session with {@link upsertSession} when you initiate a stream, so the peer's subsequent commands for that
+ *   session id are accepted; commands for an unknown session or a mismatched fabric/peer are rejected with NotFound.
+ * * Subscribe to the `offer` / `answer` / `iceCandidates` / `end` events to feed your WebRTC stack. A session is removed
+ *   from tracking automatically when the peer sends End.
+ * * Call {@link removeSession} when you tear a stream down locally.
+ *
+ * On the first commissioned fabric the implementation installs an Operate-privilege ACL entry granting that fabric
+ * access to this cluster, so the peer can reach the signaling commands without further configuration.
  */
-export class WebRtcTransportRequestorServer extends WebRtcTransportRequestorBehavior {}
+export class WebRtcTransportRequestorServer extends WebRtcTransportRequestorBehavior {
+    declare readonly events: WebRtcTransportRequestorServer.Events;
+
+    override async initialize() {
+        const node = Node.forEndpoint(this.endpoint) as ServerNode;
+        logger.info(
+            `WebRtcTransportRequestor initialized on endpoint=${this.endpoint.number} (id="${this.endpoint.id}")`,
+        );
+        this.reactTo(node.lifecycle.online, this.#nodeOnline);
+        if (node.lifecycle.isOnline) {
+            await this.#nodeOnline();
+        }
+    }
+
+    async #nodeOnline() {
+        const fabricAuthority = this.env.get(FabricAuthority);
+        const ownFabric = fabricAuthority.fabrics[0];
+        if (!ownFabric) {
+            this.reactTo(fabricAuthority.fabricAdded, this.#nodeOnline, { once: true });
+            return;
+        }
+
+        const node = Node.forEndpoint(this.endpoint) as ServerNode;
+        await node.act(agent => agent.load(AccessControlServer));
+        if (node.behaviors.has(AccessControlServer)) {
+            if (
+                !node
+                    .stateOf(AccessControlServer)
+                    .acl.some(
+                        ({ fabricIndex, privilege, authMode, subjects, targets }) =>
+                            fabricIndex === ownFabric.fabricIndex &&
+                            privilege === AccessControl.AccessControlEntryPrivilege.Operate &&
+                            authMode === AccessControl.AccessControlEntryAuthMode.Case &&
+                            subjects?.length === 0 &&
+                            targets?.length === 1 &&
+                            targets[0].endpoint === this.endpoint.number &&
+                            targets[0].cluster === WebRtcTransportRequestor.id,
+                    )
+            ) {
+                const acl = [
+                    ...node.stateOf(AccessControlServer).acl,
+                    {
+                        fabricIndex: ownFabric.fabricIndex,
+                        privilege: AccessControl.AccessControlEntryPrivilege.Operate,
+                        authMode: AccessControl.AccessControlEntryAuthMode.Case,
+                        subjects: [],
+                        targets: [{ endpoint: this.endpoint.number, cluster: WebRtcTransportRequestor.id }],
+                    },
+                ];
+                await node.setStateOf(AccessControlServer, { acl });
+            }
+        }
+    }
+
+    /**
+     * Register or update a WebRTC session you have initiated with a peer. A session must be registered before the peer's
+     * signaling commands for the matching session id are accepted, and registration populates the `currentSessions`
+     * attribute. Re-registering an existing id replaces the entry.
+     */
+    upsertSession(session: WebRtcSession): void {
+        const enriched: WebRtcSession = {
+            ...session,
+            videoStreamId: session.videoStreams?.[0] ?? null,
+            audioStreamId: session.audioStreams?.[0] ?? null,
+        };
+        const sessions = this.state.currentSessions;
+        const idx = sessions.findIndex(s => s.id === session.id);
+        if (idx === -1) {
+            this.state.currentSessions = [...sessions, enriched];
+        } else {
+            this.state.currentSessions = sessions.map((s, i) => (i === idx ? enriched : s));
+        }
+    }
+
+    /** Stop tracking a session, e.g. after you tear down the stream locally. No-op if the id is unknown. */
+    removeSession(id: number): void {
+        const sessions = this.state.currentSessions;
+        if (sessions.some(s => s.id === id)) {
+            this.state.currentSessions = sessions.filter(s => s.id !== id);
+        }
+    }
+
+    /**
+     * Invoked by the peer to deliver an SDP offer. Surfaces it via the {@link WebRtcTransportRequestorServer.Events}
+     * `offer` event.
+     */
+    override async offer(request: WebRtcTransportRequestor.OfferRequest): Promise<void> {
+        logger.debug(`incoming Offer webRtcSessionId=${request.webRtcSessionId} sdpLen=${request.sdp.length}`);
+        const session = this.#findSessionStrict(request.webRtcSessionId);
+        this.events.offer.emit(session, request);
+    }
+
+    /**
+     * Invoked by the peer to deliver an SDP answer. Surfaces it via the {@link WebRtcTransportRequestorServer.Events}
+     * `answer` event.
+     */
+    override async answer(request: WebRtcTransportRequestor.AnswerRequest): Promise<void> {
+        logger.debug(`incoming Answer webRtcSessionId=${request.webRtcSessionId} sdpLen=${request.sdp.length}`);
+        const session = this.#findSessionStrict(request.webRtcSessionId);
+        this.events.answer.emit(session, request.sdp);
+    }
+
+    /** Invoked by the peer to deliver ICE candidates. Surfaces them via the {@link WebRtcTransportRequestorServer.Events}
+     *  `iceCandidates` event.
+     */
+    override async iceCandidates(request: WebRtcTransportRequestor.IceCandidatesRequest): Promise<void> {
+        logger.debug(
+            `incoming ICECandidates webRtcSessionId=${request.webRtcSessionId} count=${request.iceCandidates.length}`,
+        );
+        if (request.iceCandidates.length === 0) {
+            throw new StatusResponseError("ICE candidates list must not be empty", Status.InvalidCommand);
+        }
+        const session = this.#findSessionStrict(request.webRtcSessionId);
+        this.events.iceCandidates.emit(session, request.iceCandidates);
+    }
+
+    /** Invoked by the peer to end a session. Removes it from tracking and surfaces it via the
+     * {@link WebRtcTransportRequestorServer.Events} `end` event.
+     */
+    override async end(request: WebRtcTransportRequestor.EndRequest): Promise<void> {
+        logger.debug(`incoming End webRtcSessionId=${request.webRtcSessionId} reason=${request.reason}`);
+        const session = this.#findSessionStrict(request.webRtcSessionId);
+        this.removeSession(request.webRtcSessionId);
+        this.events.end.emit(session, request.reason);
+    }
+
+    #findSessionStrict(id: number): WebRtcSession {
+        assertRemoteActor(this.context);
+        NodeSession.assert(this.context.session);
+        const peer = this.context.session.peerAddress;
+        const session = this.state.currentSessions.find(s => s.id === id);
+        if (session === undefined || session.fabricIndex !== peer.fabricIndex || session.peerNodeId !== peer.nodeId) {
+            throw new StatusResponseError(`WebRTC session ${id} not found`, Status.NotFound);
+        }
+        return session;
+    }
+}
+
+export namespace WebRtcTransportRequestorServer {
+    /** Transport-signaling events the peer triggers; subscribe to these to drive your WebRTC peer connection. */
+    export class Events extends WebRtcTransportRequestorBehavior.Events {
+        /** Peer sent an SDP offer for a tracked session; apply it to your peer connection. */
+        offer = Observable<[session: WebRtcSession, args: WebRtcTransportRequestor.OfferRequest]>();
+
+        /** Peer sent an SDP answer for a tracked session. */
+        answer = Observable<[session: WebRtcSession, sdp: string]>();
+
+        /** Peer sent ICE candidates for a tracked session; add them to your peer connection. */
+        iceCandidates = Observable<[session: WebRtcSession, candidates: WebRtcTransportDefinitions.IceCandidate[]]>();
+
+        /** Peer ended a session; the session is already removed from tracking when this fires. */
+        end = Observable<[session: WebRtcSession, reason: WebRtcTransportDefinitions.WebRtcEndReason]>();
+    }
+}

package/src/devices/air-purifier.ts

@@ -26,7 +26,7 @@ import { Identity } from "@matter/general";
  * It is a device that has a fan to control the air speed while it is operating. Optionally, it can report on the
  * condition of its filters.
  *
- * @see {@link MatterSpecification.v151.Device} § 9.3
+ * @see {@link MatterSpecification.v16.Device} § 9.3
  */
 export interface AirPurifierDevice extends Identity<typeof AirPurifierDeviceDefinition> {}
 

package/src/devices/air-quality-sensor.ts

@@ -54,7 +54,7 @@ import { Identity } from "@matter/general";
  * An air quality sensor is a device designed to monitor and measure various parameters related to the quality of
  * ambient air in indoor or outdoor environments.
  *
- * @see {@link MatterSpecification.v151.Device} § 7.10
+ * @see {@link MatterSpecification.v16.Device} § 7.10
  */
 export interface AirQualitySensorDevice extends Identity<typeof AirQualitySensorDeviceDefinition> {}
 

package/src/devices/audio-doorbell.ts

@@ -38,7 +38,7 @@ import { Identity } from "@matter/general";
  * AudioDoorbellDevice requires Switch and CameraAvStreamManagement clusters but they are not added by default because
  * you must select the features your device supports. You can add manually using AudioDoorbellDevice.with().
  *
- * @see {@link MatterSpecification.v151.Device} § 16.5
+ * @see {@link MatterSpecification.v16.Device} § 16.5
  */
 export interface AudioDoorbellDevice extends Identity<typeof AudioDoorbellDeviceDefinition> {}
 

package/src/devices/basic-video-player.ts

@@ -37,7 +37,7 @@ import { Identity } from "@matter/general";
  * See Section 10.1, "Video Player Architecture" for additional Basic Video Player requirements relating to Video Player
  * device endpoint composition, commissioning, feature representation in clusters, and UI context.
  *
- * @see {@link MatterSpecification.v151.Device} § 10.2
+ * @see {@link MatterSpecification.v16.Device} § 10.2
  */
 export interface BasicVideoPlayerDevice extends Identity<typeof BasicVideoPlayerDeviceDefinition> {}
 

package/src/devices/battery-storage.ts

@@ -18,7 +18,7 @@ import { Identity } from "@matter/general";
  * energy consumed in premises. It is not intended to be used for a UPS directly supplying a set of appliances, nor for
  * portable battery storage devices.
  *
- * @see {@link MatterSpecification.v151.Device} § 14.4
+ * @see {@link MatterSpecification.v16.Device} § 14.4
  */
 export interface BatteryStorageDevice extends Identity<typeof BatteryStorageDeviceDefinition> {}
 

package/src/devices/camera-controller.ts

@@ -40,7 +40,7 @@ import { Identity } from "@matter/general";
 /**
  * A Camera controller device is a device that provides interfaces for controlling and managing camera devices.
  *
- * @see {@link MatterSpecification.v151.Device} § 16.8
+ * @see {@link MatterSpecification.v16.Device} § 16.8
  */
 export interface CameraControllerDevice extends Identity<typeof CameraControllerDeviceDefinition> {}
 

package/src/devices/camera.ts

@@ -43,7 +43,7 @@ import { Identity } from "@matter/general";
  * CameraDevice requires CameraAvStreamManagement cluster but CameraAvStreamManagement is not added by default because
  * you must select the features your device supports. You can add manually using CameraDevice.with().
  *
- * @see {@link MatterSpecification.v151.Device} § 16.1
+ * @see {@link MatterSpecification.v16.Device} § 16.1
  */
 export interface CameraDevice extends Identity<typeof CameraDeviceDefinition> {}
 

package/src/devices/casting-video-client.ts

@@ -39,7 +39,7 @@ import { Identity } from "@matter/general";
  * A Casting Video Client is a client that can launch content on a Casting Video Player, for example, a Smart Speaker or
  * a Content Provider phone app.
  *
- * @see {@link MatterSpecification.v151.Device} § 10.6
+ * @see {@link MatterSpecification.v16.Device} § 10.6
  */
 export interface CastingVideoClientDevice extends Identity<typeof CastingVideoClientDeviceDefinition> {}
 

package/src/devices/casting-video-player.ts

@@ -41,7 +41,7 @@ import { Identity } from "@matter/general";
  * See Section 10.1, "Video Player Architecture" for additional Casting Video Player requirements relating to Video
  * Player device endpoint composition, commissioning, feature representation in clusters, and UI context.
  *
- * @see {@link MatterSpecification.v151.Device} § 10.3
+ * @see {@link MatterSpecification.v16.Device} § 10.3
  */
 export interface CastingVideoPlayerDevice extends Identity<typeof CastingVideoPlayerDeviceDefinition> {}
 

package/src/devices/chime.ts

@@ -16,7 +16,7 @@ import { Identity } from "@matter/general";
  * A Chime device is a device which can play from a range of pre installed sounds and is typically used with a Doorbell,
  * Audio Doorbell, or Video Doorbell.
  *
- * @see {@link MatterSpecification.v151.Device} § 16.7
+ * @see {@link MatterSpecification.v16.Device} § 16.7
  */
 export interface ChimeDevice extends Identity<typeof ChimeDeviceDefinition> {}
 

package/src/devices/closure-controller.ts

@@ -8,7 +8,6 @@
 
 import { ClosureControlClient as BaseClosureControlClient } from "../behaviors/closure-control/ClosureControlClient.js";
 import { IdentifyClient as BaseIdentifyClient } from "../behaviors/identify/IdentifyClient.js";
-import { GroupsClient as BaseGroupsClient } from "../behaviors/groups/GroupsClient.js";
 import {
     ClosureDimensionClient as BaseClosureDimensionClient
 } from "../behaviors/closure-dimension/ClosureDimensionClient.js";
@@ -19,7 +18,7 @@ import { Identity } from "@matter/general";
 /**
  * A Closure Controller is capable of controlling a Closure.
  *
- * @see {@link MatterSpecification.v151.Device} § 8.7
+ * @see {@link MatterSpecification.v16.Device} § 8.7
  */
 export interface ClosureControllerDevice extends Identity<typeof ClosureControllerDeviceDefinition> {}
 
@@ -38,13 +37,6 @@ export namespace ClosureControllerRequirements {
      */
     export const IdentifyClient = BaseIdentifyClient;
 
-    /**
-     * The Groups cluster is optional per the Matter specification.
-     *
-     * We provide this alias to the default implementation {@link GroupsClient} for convenience.
-     */
-    export const GroupsClient = BaseGroupsClient;
-
     /**
      * The ClosureDimension cluster is optional per the Matter specification.
      *
@@ -57,7 +49,7 @@ export namespace ClosureControllerRequirements {
      */
     export const client = {
         mandatory: { ClosureControl: ClosureControlClient },
-        optional: { Identify: IdentifyClient, Groups: GroupsClient, ClosureDimension: ClosureDimensionClient }
+        optional: { Identify: IdentifyClient, ClosureDimension: ClosureDimensionClient }
     };
 }
 

package/src/devices/closure-panel.ts

@@ -31,7 +31,7 @@ import { Identity } from "@matter/general";
  * ClosurePanelDevice requires ClosureDimension cluster but ClosureDimension is not added by default because you must
  * select the features your device supports. You can add manually using ClosurePanelDevice.with().
  *
- * @see {@link MatterSpecification.v151.Device} § 8.6
+ * @see {@link MatterSpecification.v16.Device} § 8.6
  */
 export interface ClosurePanelDevice extends Identity<typeof ClosurePanelDeviceDefinition> {}
 

package/src/devices/closure.ts

@@ -23,7 +23,7 @@ import { Identity } from "@matter/general";
  * ClosureDevice requires ClosureControl cluster but ClosureControl is not added by default because you must select the
  * features your device supports. You can add manually using ClosureDevice.with().
  *
- * @see {@link MatterSpecification.v151.Device} § 8.5
+ * @see {@link MatterSpecification.v16.Device} § 8.5
  */
 export interface ClosureDevice extends Identity<typeof ClosureDeviceDefinition> {}
 

package/src/devices/color-dimmer-switch.ts

@@ -23,7 +23,7 @@ import { Identity } from "@matter/general";
  * A Color Dimmer Switch is a controller device that, when bound to a lighting device such as an Extended Color Light,
  * is capable of being used to adjust the color of the light being emitted.
  *
- * @see {@link MatterSpecification.v151.Device} § 6.3
+ * @see {@link MatterSpecification.v16.Device} § 6.3
  */
 export interface ColorDimmerSwitchDevice extends Identity<typeof ColorDimmerSwitchDeviceDefinition> {}
 

package/src/devices/color-temperature-light.ts

@@ -26,7 +26,7 @@ import { Identity } from "@matter/general";
  * light adjusted, and its color temperature adjusted by means of a bound controller device such as a Color Dimmer
  * Switch.
  *
- * @see {@link MatterSpecification.v151.Device} § 4.3
+ * @see {@link MatterSpecification.v16.Device} § 4.3
  */
 export interface ColorTemperatureLightDevice extends Identity<typeof ColorTemperatureLightDeviceDefinition> {}
 

package/src/devices/contact-sensor.ts

@@ -18,7 +18,7 @@ import { Identity } from "@matter/general";
 /**
  * This defines conformance to the Contact Sensor device type.
  *
- * @see {@link MatterSpecification.v151.Device} § 7.1
+ * @see {@link MatterSpecification.v16.Device} § 7.1
  */
 export interface ContactSensorDevice extends Identity<typeof ContactSensorDeviceDefinition> {}