@matter/node 0.16.0-alpha.0-20251103-b47ffa15b → 0.16.0-alpha.0-20251106-4e10fd77b

package/src/node/NodePhysicalProperties.ts

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { NetworkCommissioningClient } from "#behaviors/network-commissioning";
+import { PowerSourceClient } from "#behaviors/power-source";
+import { ThreadNetworkDiagnosticsClient } from "#behaviors/thread-network-diagnostics";
+import { PowerSource } from "#clusters/power-source";
+import { ThreadNetworkDiagnostics } from "#clusters/thread-network-diagnostics";
+import { Endpoint } from "#endpoint/index.js";
+import { AggregatorEndpoint } from "#endpoints/aggregator";
+import { IcdManagement } from "#model";
+import { Node } from "#node/Node.js";
+import { PhysicalDeviceProperties } from "#protocol";
+import { ClusterId } from "#types";
+
+/**
+ * Inspects a node to generate {@link PhysicalDeviceProperties}.
+ */
+export function NodePhysicalProperties(node: Node) {
+    const rootEndpointServerList = [...node.state.descriptor.serverList];
+
+    const properties: PhysicalDeviceProperties = {
+        threadConnected: false,
+        wifiConnected: false,
+        ethernetConnected: false,
+        rootEndpointServerList,
+        isMainsPowered: false,
+        isBatteryPowered: false,
+        isIntermittentlyConnected: rootEndpointServerList.includes(IcdManagement.id as ClusterId),
+        isThreadSleepyEndDevice: false,
+    };
+
+    inspectEndpoint(node, properties);
+
+    return properties;
+}
+
+function inspectEndpoint(endpoint: Endpoint, properties: PhysicalDeviceProperties) {
+    // Network interface support
+    const network = endpoint.behaviors.typeFor(NetworkCommissioningClient);
+    if (network) {
+        const features = network.schema.supportedFeatures;
+        if (features.has("WI")) {
+            properties.wifiConnected = true;
+        }
+        if (features.has("TH")) {
+            properties.threadConnected = true;
+        }
+        if (features.has("ET")) {
+            properties.ethernetConnected = true;
+        }
+    }
+
+    // Battery power
+    const powerSource = endpoint.behaviors.typeFor(PowerSourceClient);
+    if (powerSource) {
+        const features = powerSource.schema.supportedFeatures;
+        if (features.has("WIRED")) {
+            if (endpoint.stateOf(PowerSourceClient).status === PowerSource.PowerSourceStatus.Active) {
+                // Should we only consider A/C "mains" powered?  What is a DC adapter?  What is an external battery?
+                // For now assuming "wired" means "don't worry about power consumption"
+                properties.isMainsPowered = true;
+            }
+        } else if (
+            features.has("BAT") ||
+            // Perform additional checks because we've encountered devices with incorrect features
+            !features.has("WIRED") ||
+            endpoint.behaviors.elementsOf(powerSource).attributes.has("batChargeLevel")
+        ) {
+            if (
+                endpoint.stateOf(PowerSourceClient).status === PowerSource.PowerSourceStatus.Active ||
+                // Some devices do not properly specify state as active
+                endpoint.stateOf(PowerSourceClient).status === PowerSource.PowerSourceStatus.Unspecified
+            ) {
+                properties.isBatteryPowered = true;
+            }
+        }
+    }
+
+    // Sleepy thread device
+    const threadNetworkDiagnostics = endpoint.behaviors.typeFor(ThreadNetworkDiagnosticsClient);
+    if (
+        threadNetworkDiagnostics &&
+        endpoint.stateOf(threadNetworkDiagnostics).routingRole === ThreadNetworkDiagnostics.RoutingRole.SleepyEndDevice
+    ) {
+        properties.isThreadSleepyEndDevice = true;
+    }
+
+    // Recurse into children
+    //
+    // Do not recurse into aggregator endpoints as bridged nodes are not relevant.  The check for mains power should
+    // otherwise cover us for properly structured devices.  For other devices err on the side of caution and assume
+    // mention of a battery on any endpoint means the entire node is battery powered.
+    //
+    // Technically according to spec we are handling the following incorrectly:
+    //
+    //   * Power source on application endpoint without EndpointList attribute (per spec power source does not apply to
+    //     node as a whole)
+    //
+    //   * Power source on any endpoint with non-empty EndpointList that does not include endpoint 0 (per spec this does
+    //     not indicate node is battery powered)
+    //
+    // The only downside of getting this wrong is that we will operate with degraded response time to changes.
+    for (const part of endpoint.parts) {
+        if (part.number !== 0 && part.type.deviceType === AggregatorEndpoint.deviceType) {
+            continue;
+        }
+        inspectEndpoint(part, properties);
+    }
+}

package/src/node/ServerNode.ts

@@ -215,3 +215,5 @@ export namespace ServerNode {
 
     export interface RootEndpoint extends Identity<typeof RootEndpoint> {}
 }
+
+Object.freeze(ServerNode.RootEndpoint);

package/src/node/client/ClientEndpointInitializer.ts

@@ -12,7 +12,7 @@ import { ServerBehaviorBacking } from "#behavior/internal/ServerBehaviorBacking.
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
 import { FeatureBitmap } from "#model";
-import { ClientBehavior } from "#node/client/ClientBehavior.js";
+import { PeerBehavior } from "#node/client/PeerBehavior.js";
 import type { ClientNode } from "#node/ClientNode.js";
 import { ClientNodeStore } from "#storage/client/ClientNodeStore.js";
 import { NodeStore } from "#storage/NodeStore.js";
@@ -84,7 +84,7 @@ export class ClientEndpointInitializer extends EndpointInitializer {
             commands.push(cmd.requestId);
         }
 
-        return ClientBehavior({
+        return PeerBehavior({
             id: cluster.id,
             revision: cluster.revision,
             features,

package/src/node/client/ClientNodeInteraction.ts

@@ -7,12 +7,14 @@
 import type { ActionContext } from "#behavior/context/ActionContext.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
 import type { ClientNode } from "#node/ClientNode.js";
+import { NodePhysicalProperties } from "#node/NodePhysicalProperties.js";
 import {
     ClientInteraction,
     ClientInvoke,
     ClientSubscribe,
     DecodedInvokeResult,
     Interactable,
+    PhysicalDeviceProperties,
     Read,
     ReadResult,
     SubscribeResult,
@@ -31,6 +33,15 @@ export class ClientNodeInteraction implements Interactable<ActionContext> {
         this.#node = node;
     }
 
+    /**
+     * The current session used for interaction with the node if any session is established, otherwise undefined.
+     */
+    get session() {
+        if (this.#node.env.has(ClientInteraction)) {
+            return this.#node.env.get(ClientInteraction).session;
+        }
+    }
+
     /**
      * Read chosen attributes remotely from the node. Known data versions are automatically injected into the request to
      * optimize the read.
@@ -53,8 +64,15 @@ export class ClientNodeInteraction implements Interactable<ActionContext> {
      * automatically.  So you normally do not need to subscribe manually.
      */
     async subscribe(request: ClientSubscribe, context?: ActionContext): SubscribeResult {
+        const physicalProps = NodePhysicalProperties(this.#node);
+
         const intermediateRequest: ClientSubscribe = {
             ...this.structure.injectVersionFilters(request),
+            ...PhysicalDeviceProperties.subscriptionIntervalBoundsFor({
+                description: this.#node.toString(),
+                properties: physicalProps,
+                request,
+            }),
 
             sustain: request.sustain === undefined ? true : request.sustain,
 

package/src/node/client/ClientStructure.ts

@@ -7,21 +7,31 @@
 import { Behavior } from "#behavior/Behavior.js";
 import { ClusterBehavior } from "#behavior/cluster/ClusterBehavior.js";
 import { Datasource } from "#behavior/state/managed/Datasource.js";
-import { DescriptorCluster } from "#clusters/descriptor";
+import { Descriptor } from "#clusters/descriptor";
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
-import { AcceptedCommandList, AttributeList, ClusterRevision, FeatureMap, type FeatureBitmap } from "#model";
+import { RootEndpoint } from "#endpoints/root";
+import {
+    AcceptedCommandList,
+    AttributeList,
+    ClusterRevision,
+    DeviceClassification,
+    DeviceTypeModel,
+    FeatureMap,
+    Matter,
+    type FeatureBitmap,
+} from "#model";
 import type { ClientNode } from "#node/ClientNode.js";
 import { ReadScope, type Read, type ReadResult } from "#protocol";
 import { DatasourceCache } from "#storage/client/DatasourceCache.js";
 import { ClientNodeStore } from "#storage/index.js";
-import type { AttributeId, ClusterId, ClusterType, CommandId, DeviceTypeId, EndpointNumber } from "#types";
-import { ClientBehavior } from "./ClientBehavior.js";
+import type { AttributeId, ClusterId, ClusterType, CommandId, EndpointNumber } from "#types";
 import { ClientEventEmitter } from "./ClientEventEmitter.js";
+import { PeerBehavior } from "./PeerBehavior.js";
 
-const DEVICE_TYPE_LIST_ATTR_ID = DescriptorCluster.attributes.deviceTypeList.id;
-const SERVER_LIST_ATTR_ID = DescriptorCluster.attributes.serverList.id;
-const PARTS_LIST_ATTR_ID = DescriptorCluster.attributes.partsList.id;
+const DEVICE_TYPE_LIST_ATTR_ID = Descriptor.Cluster.attributes.deviceTypeList.id;
+const SERVER_LIST_ATTR_ID = Descriptor.Cluster.attributes.serverList.id;
+const PARTS_LIST_ATTR_ID = Descriptor.Cluster.attributes.partsList.id;
 
 /**
  * Manages endpoint and behavior structure for a single client node.
@@ -285,26 +295,52 @@ export class ClientStructure {
                 cluster.attributes !== undefined &&
                 cluster.commands !== undefined
             ) {
-                cluster.behavior = ClientBehavior(cluster as ClientBehavior.ClusterShape);
+                cluster.behavior = PeerBehavior(cluster as PeerBehavior.ClusterShape);
                 endpoint.endpoint.behaviors.require(cluster.behavior);
             }
         }
 
         // Special handling for descriptor cluster
-        if (cluster.id === DescriptorCluster.id) {
+        if (cluster.id === Descriptor.Cluster.id) {
             this.#synchronizeDescriptor(endpoint, attrs);
         }
     }
 
     #synchronizeDescriptor(endpoint: EndpointStructure, attrs: Record<number, unknown>) {
-        const deviceTypeList = attrs[DEVICE_TYPE_LIST_ATTR_ID];
-        if (Array.isArray(deviceTypeList) && deviceTypeList?.[0]) {
-            const [{ deviceType, revision }] = deviceTypeList;
-            if (typeof deviceType === "number") {
-                endpoint.endpoint.type.deviceType = deviceType as DeviceTypeId;
-            }
-            if (typeof revision === "number") {
-                endpoint.endpoint.type.deviceRevision = revision;
+        const deviceTypeList = attrs[DEVICE_TYPE_LIST_ATTR_ID] as Descriptor.DeviceType[];
+        if (Array.isArray(deviceTypeList)) {
+            const endpointType = endpoint.endpoint.type;
+            for (const dt of deviceTypeList) {
+                if (typeof dt?.deviceType !== "number") {
+                    continue;
+                }
+
+                let isApp = false;
+                const model = Matter.get(DeviceTypeModel, dt.deviceType);
+                if (model !== undefined) {
+                    isApp = DeviceClassification.isApplication(model.classification);
+                }
+
+                // Root endpoint really needs to be a root endpoint so ignore any noise that would disrupt that
+                if (!endpoint.endpoint.number && endpointType.deviceType !== RootEndpoint.deviceType) {
+                    endpointType.deviceRevision = dt.revision;
+                    break;
+                }
+
+                // Skip this device type if we've already found one and this one is not an application type
+                if (endpointType.deviceType !== undefined && !isApp) {
+                    continue;
+                }
+
+                endpointType.deviceType = dt.deviceType;
+                endpointType.deviceRevision = dt.revision;
+                endpointType.deviceClass = model?.classification ?? DeviceClassification.Simple;
+
+                // If we found a known application device type we stop because this is the classification we want to
+                // report
+                if (isApp) {
+                    break;
+                }
             }
         }
 
@@ -360,7 +396,7 @@ export class ClientStructure {
                 id: `ep${number}`,
                 number,
                 type: EndpointType({
-                    name: "ClientEndpoint",
+                    name: "Unknown",
                     deviceType: EndpointType.UNKNOWN_DEVICE_TYPE,
                     deviceRevision: EndpointType.UNKNOWN_DEVICE_REVISION,
                 }),
@@ -401,7 +437,7 @@ interface EndpointStructure {
     clusters: Record<ClusterId, ClusterStructure>;
 }
 
-interface ClusterStructure extends Partial<ClientBehavior.ClusterShape> {
+interface ClusterStructure extends Partial<PeerBehavior.ClusterShape> {
     id: ClusterId;
     behavior?: ClusterBehavior.Type;
     store: Datasource.ExternallyMutableStore;

package/src/node/client/{ClientBehavior.ts → PeerBehavior.ts}

@@ -7,7 +7,7 @@
 import { Behavior } from "#behavior/Behavior.js";
 import { ClusterBehavior } from "#behavior/cluster/ClusterBehavior.js";
 import { camelize, capitalize, InternalError } from "#general";
-import { AttributeModel, ClusterModel, CommandModel, FeatureBitmap, Matter } from "#model";
+import { AttributeModel, ClusterModel, CommandModel, Conformance, FeatureBitmap, Matter } from "#model";
 import type { ClientNode } from "#node/ClientNode.js";
 import { Node } from "#node/Node.js";
 import { ClientInteraction, Invoke } from "#protocol";
@@ -33,7 +33,7 @@ const cache = {} as Record<string, ClusterBehavior.Type>;
 /**
  * Obtain a {@link ClusterBehavior.Type} for a remote cluster.
  */
-export function ClientBehavior(shape: ClientBehavior.ClusterShape): ClusterBehavior.Type {
+export function PeerBehavior(shape: PeerBehavior.ClusterShape): ClusterBehavior.Type {
     const analysis = ShapeAnalysis(shape);
 
     const fingerprint = createFingerprint(analysis);
@@ -55,7 +55,7 @@ export function ClientBehavior(shape: ClientBehavior.ClusterShape): ClusterBehav
     return type;
 }
 
-export namespace ClientBehavior {
+export namespace PeerBehavior {
     export interface ClusterShape {
         id: ClusterId;
         revision: number;
@@ -75,7 +75,7 @@ function generateType(analysis: ShapeAnalysis, baseType: Behavior.Type): Cluster
 
     let { schema } = analysis;
     let isCloned = false;
-    const { extraAttrs, extraCommands } = analysis;
+    const { attrSupportOverrides, extraAttrs, commandSupportOverrides, extraCommands } = analysis;
 
     // Obtain a ClusterType.  This provides TLV for known elements
     let { cluster } = baseType;
@@ -107,7 +107,13 @@ function generateType(analysis: ShapeAnalysis, baseType: Behavior.Type): Cluster
 
     // If the schema does not match what the device actually returned, further augment both the ClusterModel and
     // ClusterType with unknown attributes and/or commands
-    if (schema.revision !== analysis.shape.revision || extraAttrs.size || extraCommands.size) {
+    if (
+        schema.revision !== analysis.shape.revision ||
+        extraAttrs.size ||
+        extraCommands.size ||
+        Object.keys(attrSupportOverrides).length ||
+        Object.keys(commandSupportOverrides).length
+    ) {
         cloneSchema();
 
         cluster = {
@@ -117,12 +123,24 @@ function generateType(analysis: ShapeAnalysis, baseType: Behavior.Type): Cluster
             commands: { ...cluster.commands },
         };
 
+        if (attrSupportOverrides) {
+            for (const [attr, isSupported] of attrSupportOverrides.entries()) {
+                schema.children.push(attr.extend({ operationalIsSupported: isSupported }));
+            }
+        }
+
         for (const id of extraAttrs) {
             const name = createUnknownName("attr", id);
             cluster.attributes[camelize(name, false)] = Attribute(id, TlvAny);
             schema.children.push(new AttributeModel({ id, name, type: "any" }));
         }
 
+        if (commandSupportOverrides) {
+            for (const [command, isSupported] of commandSupportOverrides.entries()) {
+                schema.children.push(command.extend({ operationalIsSupported: isSupported }));
+            }
+        }
+
         for (const id of extraCommands) {
             const name = createUnknownName("command", id);
             cluster.commands[camelize(name, false)] = Command(id, TlvAny, 0, TlvNoResponse);
@@ -232,30 +250,87 @@ function createUnknownName(prefix: string, id: number) {
 
 interface ShapeAnalysis {
     schema: ClusterModel & { id: ClusterId };
-    shape: ClientBehavior.ClusterShape;
+    shape: PeerBehavior.ClusterShape;
+    attrSupportOverrides: Map<AttributeModel, boolean>;
     extraAttrs: Set<number>;
+    commandSupportOverrides: Map<CommandModel, boolean>;
     extraCommands: Set<number>;
 }
 
-function ShapeAnalysis(shape: ClientBehavior.ClusterShape): ShapeAnalysis {
+/**
+ * Analyze the cluster shape to determine how we should override the behavior and schema.
+ */
+function ShapeAnalysis(shape: PeerBehavior.ClusterShape): ShapeAnalysis {
+    const standardCluster = Matter.get(ClusterModel, shape.id);
     const schema =
-        Matter.get(ClusterModel, shape.id) ??
+        standardCluster ??
         new ClusterModel({ id: shape.id, name: createUnknownName("Cluster", shape.id), revision: shape.revision });
 
-    const extraAttrs = new Set(shape.attributes);
+    const attrSupportOverrides = new Map<AttributeModel, boolean>();
+    const extraAttrs = new Set<number>(shape.attributes);
     for (const attr of schema.attributes) {
+        maybeOverrideSupport(standardCluster, attr, extraAttrs, attrSupportOverrides);
+        if (standardCluster) {
+            const supported = extraAttrs.has(attr.id);
+            const applicability = attr.conformance.applicabilityFor(standardCluster);
+            if (!supported) {
+                if (applicability) {
+                    attrSupportOverrides.set(attr, false);
+                }
+            } else {
+                if (applicability !== Conformance.Applicability.Mandatory) {
+                    attrSupportOverrides.set(attr, true);
+                }
+            }
+        }
         extraAttrs.delete(attr.id as AttributeId);
     }
 
+    const commandSupportOverrides = new Map<CommandModel, boolean>();
     const extraCommands = new Set(shape.commands);
     for (const command of schema.commands) {
+        maybeOverrideSupport(standardCluster, command, extraCommands, commandSupportOverrides);
         extraCommands.delete(command.id as CommandId);
     }
 
     return {
         schema: schema as ClusterModel & { id: ClusterId },
         shape,
+        attrSupportOverrides,
         extraAttrs,
+        commandSupportOverrides,
         extraCommands,
     };
 }
+
+/**
+ * Determine whether we need to override {@link ClusterModel#operationalIsSupported}.
+ *
+ * We do this if:
+ *
+ * * The element may be present according to the standard but is not implemented on the peer, or
+ *
+ * * the element is optional according to the standard and is implemented on the peer
+ */
+function maybeOverrideSupport<T extends AttributeModel | CommandModel>(
+    standardCluster: ClusterModel | undefined,
+    element: T,
+    supported: Set<number>,
+    overrides: Map<T, boolean>,
+) {
+    if (!standardCluster) {
+        return;
+    }
+
+    const isSupported = supported.has(element.id);
+    const applicability = element.conformance.applicabilityFor(standardCluster);
+    if (!isSupported) {
+        if (applicability) {
+            overrides.set(element, false);
+        }
+    } else {
+        if (applicability !== Conformance.Applicability.Mandatory) {
+            overrides.set(element, true);
+        }
+    }
+}

package/src/node/index.ts

@@ -8,5 +8,6 @@ export * from "./client/index.js";
 export * from "./integration/index.js";
 export * from "./Node.js";
 export * from "./NodeLifecycle.js";
+export * from "./NodePhysicalProperties.js";
 export * from "./server/index.js";
 export * from "./ServerNode.js";

package/src/tags/AreaNamespaceTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace may be used in any domain or context, to indicate an association with an indoor
  * or outdoor area of a home.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 13
+ * @see {@link MatterSpecification.v142.Namespace} § 13
  */
 export const AreaNamespaceTag = SemanticNamespace({
     id: 0x10,

package/src/tags/ClosureTag.ts

@@ -19,7 +19,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * Clients SHOULD still have support for these tags, since the tags could be used by a server certified on a previous
  * revision of Matter.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 2
+ * @see {@link MatterSpecification.v142.Namespace} § 2
  */
 export const ClosureTag = SemanticNamespace({
     id: 0x1,

package/src/tags/CompassDirectionTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace may be used in any domain or context, to indicate an association with a movement
  * into a certain compass direction. Note the difference with Chapter 4, Common Compass Location Semantic Tag Namespace.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 3
+ * @see {@link MatterSpecification.v142.Namespace} § 3
  */
 export const CompassDirectionTag = SemanticNamespace({
     id: 0x2,

package/src/tags/CompassLocationTag.ts

@@ -13,7 +13,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * in a certain compass direction (e.g. an outdoor sensor in the North garden). Note the difference with Chapter 3,
  * Common Compass Direction Semantic Tag Namespace.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 4
+ * @see {@link MatterSpecification.v142.Namespace} § 4
  */
 export const CompassLocationTag = SemanticNamespace({
     id: 0x3,

package/src/tags/DirectionTag.ts

@@ -13,7 +13,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * in a certain direction relative to the device. Note the difference with Chapter 9, Common Position Semantic Tag
  * Namespace.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 5
+ * @see {@link MatterSpecification.v142.Namespace} § 5
  */
 export const DirectionTag = SemanticNamespace({
     id: 0x4,

package/src/tags/ElectricalMeasurementTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace are restricted for use in the electrical measurement domain and shall NOT be
  * used in any other domain or context.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 12
+ * @see {@link MatterSpecification.v142.Namespace} § 12
  */
 export const ElectricalMeasurementTag = SemanticNamespace({
     id: 0xa,

package/src/tags/LandmarkNamespaceTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace may be used in any domain or context, to indicate an association with a home
  * landmark.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 10
+ * @see {@link MatterSpecification.v142.Namespace} § 10
  */
 export const LandmarkNamespaceTag = SemanticNamespace({
     id: 0x11,

package/src/tags/LaundryTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace are restricted for use in the laundry domain and shall NOT be used in any other
  * domain or context.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 14
+ * @see {@link MatterSpecification.v142.Namespace} § 14
  */
 export const LaundryTag = SemanticNamespace({
     id: 0xe,

package/src/tags/LevelTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace may be used in any domain or context, to indicate an association with a certain
  * level for a feature of a device (e.g. a button to set the speed of a fan).
  *
- * @see {@link MatterSpecification.v141.Namespace} § 6
+ * @see {@link MatterSpecification.v142.Namespace} § 6
  */
 export const LevelTag = SemanticNamespace({
     id: 0x5,

package/src/tags/LocationTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace may be used in any domain or context, to indicate an association with a location
  * of a device (e.g. an outdoor temperature sensor).
  *
- * @see {@link MatterSpecification.v141.Namespace} § 7
+ * @see {@link MatterSpecification.v142.Namespace} § 7
  */
 export const LocationTag = SemanticNamespace({
     id: 0x6,

package/src/tags/NumberTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace may be used in any domain or context, to indicate an association with a certain
  * numeric feature of a device (e.g. a numeric input button).
  *
- * @see {@link MatterSpecification.v141.Namespace} § 8
+ * @see {@link MatterSpecification.v142.Namespace} § 8
  */
 export const NumberTag = SemanticNamespace({
     id: 0x7,

package/src/tags/PositionTag.ts

@@ -26,7 +26,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The following example illustrates a compound device comprised of 9 endpoints arranged in a 3x3 grid. This example
  * uses position tags to indicate position.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 9
+ * @see {@link MatterSpecification.v142.Namespace} § 9
  */
 export const PositionTag = SemanticNamespace({
     id: 0x8,

package/src/tags/PowerSourceTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace are restricted for use in the power source domain and shall NOT be used in any
  * other domain or context.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 15
+ * @see {@link MatterSpecification.v142.Namespace} § 15
  */
 export const PowerSourceTag = SemanticNamespace({
     id: 0xf,
@@ -28,7 +28,7 @@ export const PowerSourceTag = SemanticNamespace({
          *
          * Power Source clusters with this tag shall implement the WIRED feature.
          *
-         * @see {@link MatterSpecification.v141.Namespace} § 15.1
+         * @see {@link MatterSpecification.v142.Namespace} § 15.1
          */
         Grid: { id: 0x1, label: "Grid" },
 
@@ -37,7 +37,7 @@ export const PowerSourceTag = SemanticNamespace({
          *
          * Power Source clusters with this tag shall implement the WIRED feature.
          *
-         * @see {@link MatterSpecification.v141.Namespace} § 15.2
+         * @see {@link MatterSpecification.v142.Namespace} § 15.2
          */
         Solar: { id: 0x2, label: "Solar" },
 
@@ -46,7 +46,7 @@ export const PowerSourceTag = SemanticNamespace({
          *
          * Power Source clusters with this tag shall implement the BAT feature.
          *
-         * @see {@link MatterSpecification.v141.Namespace} § 15.3
+         * @see {@link MatterSpecification.v142.Namespace} § 15.3
          */
         Battery: { id: 0x3, label: "Battery" },
 
@@ -55,7 +55,7 @@ export const PowerSourceTag = SemanticNamespace({
          *
          * Power Source clusters with this tag shall implement the BAT feature.
          *
-         * @see {@link MatterSpecification.v141.Namespace} § 15.4
+         * @see {@link MatterSpecification.v142.Namespace} § 15.4
          */
         Ev: { id: 0x4, label: "Ev" }
     }

package/src/tags/RefrigeratorTag.ts

@@ -12,7 +12,7 @@ import { SemanticNamespace } from "../endpoint/type/SemanticNamespace.js";
  * The tags contained in this namespace are restricted for use in the refrigerator domain and shall NOT be used in any
  * other domain or context.
  *
- * @see {@link MatterSpecification.v141.Namespace} § 16
+ * @see {@link MatterSpecification.v142.Namespace} § 16
  */
 export const RefrigeratorTag = SemanticNamespace({
     id: 0x41,